Port live instability, writing recovery and Link Modifier controls to 26.3

Advance to 1.0.1.54-beta.1 after player validation. Port material, vegetation, lake, terrain-volume, crystal, Dense Ores and fissure features with saved plans. Update beta documentation and release notes.

Refs #98, #104

.gitignore

@@ -32,6 +32,10 @@ bin/
 ### Mac OS ###
 .DS_Store
 
+### Python tools ###
+__pycache__/
+*.pyc
+
 ### Minecraft Modding ###
 run/
 logs/

README.md

@@ -7,9 +7,28 @@ of [Mystcraft Legacy](https://github.com/Mystcraft/Mystcraft-Legacy) to
 Minecraft 1.21.1 on NeoForge. Mystcraft veterans will recognize the writing
 flow, D'ni-inspired glyphs, libraries, crystals, and instability. Rivencraft
 also lets you author modern terrain, biomes, structures, seasons, and celestial
-bodies. It is an active pre-public-release project, not a byte-for-byte copy of
+bodies. It is an independently developed project, not a byte-for-byte copy of
 the 1.12.2 mod.
 
+The gameplay guide below describes the **Minecraft 1.21.1 release**. A separate,
+incomplete **Minecraft 26.3 beta** is available: Java 25, NeoForge 26.3.0.99,
+and a first-party Age backend (no Dynamic Dimensions or Bad Packets). It now
+supports authored terrain/biomes, structure and vegetation pages, independent
+Age weather/lighting, seeded and colorable Overworld/Nether/End/Static skies,
+independent Sun/Moon controls, multiple bodies and eclipses, seeded biome and
+feature completion, and random structure selection. Nether/End noise-biome
+materials now follow their native rules. Books now have Legacy-style spreads,
+animated fallback panels and saved destination labels; lectern stands, open-book
+drops, page collections, stations and basic progression are also ported. The latest
+beta adds Age libraries, crystal portals with animated fallback surfaces, saved
+instability scoring/provider selection, potion providers and four-color decay.
+Full writing recovery, live material profiling and other hazards remain pending.
+The beta does not yet provide full
+1.21.1 gameplay or optional-integration parity.
+See the [26.3 beta guide](ports/mc263/README.md) and
+[latest beta release notes](ports/mc263/RELEASE_NOTES_1.0.1.120-beta.1.md).
+Keep the builds and their saves separate, and back up worlds before updating.
+
 ## Getting started
 
 1. Make an Ink Vial from two black dyes, a glass bottle, and a water bucket.

docs/MINECRAFT_26_3_ALPHA_1.md

@@ -0,0 +1,42 @@
+# Rivencraft 1.0.1.2-alpha.1 — Minecraft 26.3
+
+Experimental **NeoForge 26.3** port preview. This is a separate artifact from
+the supported Minecraft 1.21.1 release, and it does **not** have feature
+parity. Use a disposable test world or make a backup first. Do not migrate a
+1.21.1 Rivencraft world to this alpha.
+
+## Working in this alpha
+
+- Rivencraft loads on Minecraft 26.3 / NeoForge 26.3.0.99 with Java 25.
+- The first-party runtime Age backend creates separately seeded, persistent
+  prototype dimensions. The operator-only `/rivencraft_port age` commands can
+  create and inspect them.
+- Runtime Age catalogs are synchronized and acknowledged before cross-dimension
+  travel. A missing or unacknowledged destination is refused.
+- Operator-created Descriptive Books can enter prototype Ages.
+- Handheld Linking Books can be named and bound to a location, then used from
+  their book GUI to return there. The destination data survives a restart.
+- The Crystal Block and Crystal Shard are registered with reused art.
+
+## Not yet ported
+
+Normal authored Age generation, book crafting and workstations, Page symbols,
+most blocks and items, portal systems, Link modifiers, the rotating destination
+preview, instability, and optional mod integrations. The Linking Book GUI shows
+a placeholder destination panel rather than a live scene. Generated Ages use
+prototype vanilla terrain, not the player's authored Pages.
+
+The [26.3 port status](MINECRAFT_26_3_PORT.md) and [open port issues](https://git.paddedcell.org/dnorberg/rivencraft/issues)
+track the remaining work. The stable 1.21.1 release remains available
+separately. Please file alpha bugs with the exact Minecraft, NeoForge and
+Rivencraft versions, plus the relevant client/server log.
+
+## Verification
+
+- Clean 26.3 Gradle build passed.
+- Disposable dedicated-server smoke test passed: two distinct Age seeds and
+  their terrain persisted across a restart.
+- The user verified the handheld Linking Book GUI click and travel in-game on
+  2026-10-27.
+
+These checks are **not** the full port acceptance matrix or a stability claim.

docs/MINECRAFT_26_3_ALPHA_2.md

@@ -0,0 +1,37 @@
+# Rivencraft 1.0.1.3-alpha.1 — Minecraft 26.3
+
+Experimental **NeoForge 26.3** port preview. This is separate from the
+supported Minecraft 1.21.1 release and does **not** have feature parity. Use
+a disposable test world or make a backup first. Do not migrate a 1.21.1
+Rivencraft world to this alpha.
+
+## Changes since 1.0.1.2-alpha.1
+
+- An unbound Descriptive Book now opens a naming screen. Binding it creates a
+  distinct prototype Age with a random seed; duplicate names receive a
+  numbered suffix.
+- A bound Descriptive Book opens a book screen whose destination panel can be
+  clicked to enter its Age. The server validates the held book and waits for
+  the client's Age catalog acknowledgement before travel.
+- Retired Age IDs are excluded when assigning a new book's Age name, so an
+  archived world cannot be silently reused.
+
+## Still experimental
+
+These Ages use prototype vanilla terrain. Page-authored generation, crafting
+and workstations, most items and blocks, portals, Link modifiers, instability,
+live destination previews, and optional mod integrations are not ported. The
+book panel is a placeholder, not a rendered destination view. The
+[port status](MINECRAFT_26_3_PORT.md) and [open port issues](https://git.paddedcell.org/dnorberg/rivencraft/issues)
+track the remaining work. The stable 1.21.1 release remains available
+separately.
+
+## Verification
+
+- Clean 26.3 Gradle build passed.
+- Disposable dedicated-server smoke test passed: two distinct Age seeds and
+  their terrain persisted across restart.
+- The player verified Descriptive Book binding and travel in game on
+  2026-10-29.
+
+These checks are **not** the full port acceptance matrix or a stability claim.

docs/PUBLISHING_APIS.md

@@ -0,0 +1,82 @@
+# Publishing Rivencraft with the Gitea, Modrinth, and CurseForge APIs
+
+The local helper is [`scripts/publish_mod_sites.py`](../scripts/publish_mod_sites.py).
+It previews a release unless `--publish` is explicitly supplied. The current
+configuration is for the Minecraft **26.3** artifact only. The 1.21.1 line needs
+its required external dependencies mapped on both sites before API publishing
+is enabled for it.
+
+## One-time token setup
+
+For Gitea, an existing personal access token is sufficient if it has
+`write:repository` scope. That scope covers release creation and attachment
+upload; do not grant `all` if a narrower token is available. Create or inspect
+tokens under [Gitea user settings → Applications](https://git.paddedcell.org/user/settings/applications).
+The helper checks token identity and scope without displaying the secret.
+
+Create a [Modrinth personal access token](https://docs.modrinth.com/api/#authentication)
+in account settings with `VERSION_CREATE` (upload) and `USER_READ` (read-only
+credential check) scopes. Create a
+[CurseForge Upload API token](https://support.curseforge.com/support/solutions/articles/9000197321)
+from the author's API Tokens page. Treat both as passwords: never put them in
+git, chat, a release note, or a command-line argument.
+
+In a terminal at the repository root, run these one at a time and paste the
+corresponding token into the hidden prompt:
+
+```sh
+python3 scripts/publish_mod_sites.py store-token modrinth
+python3 scripts/publish_mod_sites.py store-token curseforge
+python3 scripts/publish_mod_sites.py store-token gitea
+```
+
+The tokens are stored in the desktop Secret Service keyring under
+`application=rivencraft-publishing`, separately by site. The script also accepts
+`RIVENCRAFT_MODRINTH_TOKEN` or `RIVENCRAFT_CURSEFORGE_TOKEN` environment variables,
+but these take precedence over keyring entries and should not be put in shell
+history or startup files.
+
+Verify the credentials without uploading anything:
+
+```sh
+python3 scripts/publish_mod_sites.py check-token modrinth
+python3 scripts/publish_mod_sites.py check-token curseforge
+python3 scripts/publish_mod_sites.py check-token gitea
+```
+
+## Release workflow
+
+Build the JAR, write a Markdown changelog, and preview the metadata:
+
+```sh
+python3 scripts/publish_mod_sites.py release \
+  --jar ports/mc263/build/libs/rivencraft-26.3-1.0.1.32-beta.1.jar \
+  --changelog ports/mc263/RELEASE_NOTES_1.0.1.32-beta.1.md \
+  --version 1.0.1.32-beta.1 \
+  --name 'Rivencraft 1.0.1.32-beta.1 — NeoForge 26.3' \
+  --minecraft 26.3 --java 25 --channel beta
+```
+
+For a *new* version only, append `--publish` to upload to both sites. Use
+`--site modrinth` or `--site curseforge` to target one site. Modrinth rejects an
+existing version number; CurseForge may not, so check its file list before any
+retry after a partial failure. CurseForge approval may take additional time.
+
+The default destination is now all three sites. The Gitea release step requires
+the annotated version tag to have been pushed first. Gitea's `Vx.y.z.b-mc26.3-beta.1`
+tag convention is derived from the version and channel; an existing release
+with different title or notes is never overwritten. If release creation
+succeeds but its JAR upload fails, rerun with `--site gitea --publish` to resume
+only the missing attachment. `--site both` retains the earlier Modrinth and
+CurseForge-only behavior.
+
+The helper uses Gitea's documented
+[`POST /repos/{owner}/{repo}/releases`](https://docs.gitea.com/api/operations/repo-create-release/)
+and [release attachment endpoint](https://docs.gitea.com/api/operations/repo-create-release-attachment/),
+plus Modrinth's documented multipart
+[`POST /version`](https://docs.modrinth.com/api/operations/createversion/) and
+CurseForge's documented
+[`POST /api/projects/{projectId}/upload-file`](https://support.curseforge.com/support/solutions/articles/9000197321)
+with the JAR, changelog, version channel, NeoForge, Minecraft version, Java
+version, and client/server environment. It sets no external dependencies for
+26.3, which uses Rivencraft's first-party Age backend.

ports/mc263/RELEASE_NOTES_1.0.1.106-beta.1.md

@@ -0,0 +1,85 @@
+# Rivencraft 26.3 beta 1.0.1.106-beta.1
+
+Collects the player-validated port slices .99–.106 since 1.0.1.98-beta.1.
+This beta is not yet feature-complete with Minecraft 1.21.1.
+
+## Books and travel
+
+- Fallback Age platforms now use the dedicated non-collectible platform block
+  from 1.21.1: opaque crystal texture, glass-like breaking strength, no drops
+  or pick-block item. Existing ordinary Crystal Block platforms are unchanged.
+- Ported automatic Return Links for successful handheld Descriptive Book
+  travel. `descriptive_books.return_link_mode` in `config/rivencraft-local.toml`
+  defaults to **DISABLED**. `ON_CREATION` issues one on the first arrival per
+  Age/world with that mode enabled; `ALWAYS` issues one on each arrival.
+- Return Links preserve departure dimension, position and facing. They are
+  issued after Disarm and drop at the destination if inventory is full.
+  First-arrival records persist across reload, reseeding and restart.
+- Successful handheld Linking and Descriptive Book travel now leaves the
+  active book at departure as a recoverable open-book entity. Both hands are
+  supported. Failed travel or canceled entity spawning restores the book.
+- Dropped books reuse the existing textures and skyward-facing model. They
+  have a one-second pickup delay, no ordinary five-minute expiry, slow decay
+  and water/rain damage, matching 1.21.1. Their components and decay counter
+  persist through restart.
+
+## Page collections and binding
+
+- Ported Notebooks and Collation Folders with their existing editor and assets,
+  capacities of 252 and 27 positions, sparse page storage, search, scrolling,
+  page movement and inventory transfers. Link Panels are rejected by the editor.
+- Notebook crafting uses the existing leather/string pattern. The held
+  collection is locked against ordinary menu movement. Escape closes the menu
+  with search focused; search still consumes inventory/hotbar shortcuts.
+- Corrected the port's keyboard and mouse-button mappings, including arrow
+  movement, right-click handling and scrollbar dragging.
+- The Book Binder accepts collection imports: shift-click to append pages or
+  click a carried collection on the strip to insert them. Empty positions are
+  skipped and occupied page order is retained. Imports validate all inputs and
+  capacity before committing; successful imports return the empty collection.
+- Added category Symbol Portfolios to Creative, including registry-derived
+  biome, material and fluid pages. Large categories split into volumes of up
+  to 252 pages. Portfolios use the editor and Binder import flow.
+- Sealed Notebooks open into Folders containing 16 random pages using the
+  1.21.1 pool/exclusions. Survival consumes one; Creative retains the item.
+  Full inventories receive a dropped Folder. No new recipes are invented for
+  Folders, Portfolios or Sealed Notebooks; discovery/library loot is pending.
+
+## Writing Desk
+
+- Ported the two-block Writing Desk, its existing model/textures, selected-page
+  and white paper-stack display, and Legacy GUI atlases.
+- Ported 88 tabs cycled four at a time, category/search/sort/ALL views, collection
+  and loose-page storage, page movement/extraction, and server-owned catalog
+  synchronization. Link Panels cannot be stored or copied in the desk.
+- Copy previews are virtual. Taking a copy consumes one paper and one ink by
+  default while retaining the original page. `writing.symbol_ink_cost` is
+  configurable in `rivencraft-local.toml`.
+- Vials fill a 16-unit meter and return vanilla glass bottles. Refills are
+  event-driven and require bottle space. Full inventory prevents shift-copy
+  consumption. Unknown pages are retained but cannot be copied unresolved.
+- Ported crafting and adapted its recipe-unlock advancement to 26.3.
+  Removing either desk half removes its partner and drops contents once.
+- Further corrections to the desk model, focused on page/paper placement,
+  remain tracked for both versions in issue #113.
+
+## Compatibility and validation
+
+- Requires Minecraft **26.3**, NeoForge **26.3.0.99**, and **Java 25**. Dynamic
+  Dimensions and Bad Packets are not required. The 1.21.1 implementation is
+  unchanged. Use matching client/server builds; Age catalog protocol remains 10.
+- Player in-game checks passed. Both build targets passed. Targeted disposable
+  server fixtures covered ownership recovery, collection/copy transactions,
+  save/network codecs, block removal, reload/reseed and restart persistence.
+  Servers were stopped and test worlds removed. This was not a full GameTest run.
+- Full writing recovery, remaining discovery/stations, instability, crystal
+  portals, progression awards and optional integration parity remain unfinished.
+  JEI guides and discovery loot for the newly ported interactions are pending.
+  Unsupported effects remain marked red; Creative availability is not parity.
+- Back up saves. New Native Cave profiles from .97 onward cannot be read by
+  earlier betas, and newly ported items/entities also require the newer build.
+  Keep 1.21.1 and 26.3 saves separate. Machine acceleration (#112) and Native
+  Cave default biome-pool policy (#111) remain separate planned work.
+
+Report issues and help improve the wiki at
+[BlackSheep Git](https://git.paddedcell.org/dnorberg/rivencraft).

ports/mc263/RELEASE_NOTES_1.0.1.115-beta.1.md

@@ -0,0 +1,88 @@
+# Rivencraft 26.3 beta 1.0.1.115-beta.1
+
+Collects the player-validated port slices .107–.115 since 1.0.1.106-beta.1.
+Minecraft 26.3, NeoForge 26.3.0.99 and Java 25. This remains a beta with
+incomplete Minecraft 1.21.1 gameplay and optional-integration parity.
+
+## Book stands and dropped books
+
+- Place a Linking Book, Descriptive Book or Page on an empty vanilla lectern
+  to convert it into a Rivencraft book stand, preserving facing. Occupied
+  vanilla lecterns are left alone.
+- Books use the existing open-book model and textures and show their name
+  above the stand. Pages use their item artwork without a hover label,
+  retaining the 1.21.1 orientation corrections.
+- Open a bound book with an empty hand, then click its destination panel to
+  travel while leaving the book on its stand. Existing link modifiers,
+  same-dimension rules, Return Link configuration and Age-entry awards apply.
+- Shift-right-click with an empty hand retrieves the stored item and restores
+  a vanilla lectern. Breaking returns one lectern and its contents. Unwritten
+  books can be displayed; retrieve them to bind in hand in this beta.
+- Ordinary dropped Linking/Descriptive Books now become recoverable open-book
+  entities, including unwritten books, inventory/player drops, container and
+  stand drops, death/Disarm drops and ordinary book entities loaded from disk.
+- Conversion preserves the stack and components, position, motion, facing,
+  pickup delay and ownership/thrower metadata. It uses the existing open-book
+  lifetime, slow decay and water/rain behavior. Already-custom books and
+  non-book items are skipped.
+- Conversion runs after registration without world scans or force-loading.
+  The original is removed only after replacement succeeds; a canceled
+  replacement leaves the ordinary item intact and eligible on a later reload.
+- Stand travel validates source dimension, distance, loaded chunk and the exact
+  currently stored book, rejecting stale screens after removal/replacement.
+
+## Book GUIs and names
+
+- Descriptive Books reuse the Legacy gilded cover, name/author front spread,
+  and one authored symbol at a time on following right-hand pages. Saved page
+  order and repetitions are retained, with runtime glyphs and no extra item outline.
+- New Descriptive Books record their author server-side. Older books without
+  that metadata use the unknown-author label.
+- Linking Books use the plain Legacy cover, wrapped title, destination name
+  and block coordinates, plus the blank final spread. Return Links suppress
+  the redundant title. Bottom corners or arrow keys turn pages with sound.
+- Both GUIs share the Legacy artwork/text/counter/corner helpers. Naming
+  controls hide on later pages and remain correct after resizing. Escape closes
+  even with naming focused; normal text input does not trigger inventory keys.
+- Ported the existing 1.21.1 fallback's animated teal spiral panel to both GUIs,
+  including lecterns. Removed placeholder labels. The Legacy frame draws over
+  the animation; travel is active only on the front panel.
+- The animated fallback is not a live destination view. Destination tint,
+  snapshot renderer integrations and random-Age glyph descriptions remain pending.
+- New Ages save their entered display name independently of their ID, folder
+  and seed. Newly bound Linking Books and automatic Return Links capture their
+  destination/departure label for both GUI and tooltip. Older Ages/books retain
+  vanilla-name or dimension-ID fallbacks; existing labels are not rewritten.
+- Corrected negative tooltip coordinates to floor consistently with the GUI.
+
+## Progression and recipe discovery
+
+- Ported the Rivencraft advancement tree: root, obtaining a Page/Linking Book,
+  taking a Link Panel from the Ink Mixer, copying a Page, binding an Age and
+  successfully travelling into an Age. Action awards occur after committed
+  server actions, including normal and shift pickup; previews earn nothing.
+- The advancement background uses the existing blue Crystal Block texture,
+  with the corrected 26.3 resource-path format. The portal node waits for the
+  Receptacle/portal port.
+- Added recipe-book discovery for Ink Vials (Black Dye), Ink Mixers (Glass
+  Bottle), Book Binders (Iron Ingot) and Crystal Blocks (Crystal Shard), alongside
+  the Notebook and Writing Desk unlocks. Three-by-three recipes appear in a
+  Crafting Table's recipe book, not the inventory's two-by-two book.
+- Ingredients and costs are unchanged. Blank Pages remain uncraftable.
+
+## Validation and remaining work
+
+- Player in-game checks passed each slice and the final dropped-book changes.
+- The 26.3 and independent 1.21.1 builds passed. Gradle test tasks have no
+  standalone test sources; targeted disposable-server fixtures covered real
+  station actions, advancements/recipe unlocks, stand ownership/drops and
+  persistence, book author/page/name persistence, and drop conversion/state.
+- Temporary test servers were stopped and their worlds deleted. A no-player
+  entity fixture required one loaded fixture chunk for inspection; further
+  visual/restart validation was handed to the player.
+- 1.21.1 gameplay code is unchanged. Shared issue #114 remains open for its
+  matching universal dropped-book fix; Writing Desk model placement stays in #113.
+- Instability, full writing recovery, discovery/library loot, crystal portals,
+  remaining stations/progression and optional integrations still need port work.
+
+Keep 26.3 and 1.21.1 instances/saves separate and back up beta worlds before updating.

ports/mc263/RELEASE_NOTES_1.0.1.120-beta.1.md

@@ -0,0 +1,85 @@
+# Rivencraft 26.3 beta 1.0.1.120-beta.1
+
+Collects the player-validated .116–.120 port slices since 1.0.1.115-beta.1.
+For Minecraft 26.3, NeoForge 26.3.0.99 and Java 25. The independent 1.21.1
+release is unchanged; full gameplay and optional-integration parity remain incomplete.
+
+## Libraries and writing
+
+- Ported Legacy library generation, shared schematic, chest loot and five correctly
+  oriented book/page stands. Libraries generate after decoration in eligible new
+  non-Cave Age chunks, using the 1.21.1 spacing, terrain and clearance checks.
+- Library loot defaults to `LEGACY`; optional `AGE_ONLY` limits new library Pages
+  to known symbols originally written into that Age. Original writing is saved
+  separately and restored on reload. Older Ages without it have an empty Age-only
+  pool. Ordinary Books replace stand Pages when that pool is empty.
+- Added operator library placement, candidate/probe/loot diagnostics, session-only
+  test spacing and a locator limited to nearby already-loaded chunks.
+- Hand-prepared Link Panel ink cost is server-configurable (default two). The
+  Ink Mixer still consumes one ink unit and one paper per panel. Writing Desk
+  ink handling now uses the shared service.
+
+## Crystal portals
+
+- Ported craftable Book Receptacles with all six mounting orientations and the
+  existing 1.21.1 model/book transforms. A bound Linking or Descriptive Book
+  activates a valid connected crystal frame, including supported irregular frames.
+- Reused the bounded crystal flood/tension algorithm, placement protection events,
+  rollback, owner persistence, restart repair, frame cleanup and traversal cooldown.
+- Empty-hand removal closes the portal and returns the book. Breaking the holder
+  or its crystal support closes it and drops a recoverable open-book entity.
+- Player and non-player travel reuse book destinations, safe arrival, Intra-Linking,
+  Disarm and momentum rules. Descriptive Books share the same landing resolver
+  with portals; no separate portal exit offset is added. Player Return Link policy
+  and progression remain in force.
+- The animated fallback surface renders its facing sides and uses destination sky
+  tint. The Open Portal advancement and receptacle recipe unlock are restored.
+  Live destination views are still pending optional integration work.
+
+## Instability and colored decay
+
+- New Ages save operator-only creation-time score contributions and deterministic
+  provider selections using all five Legacy decks. Existing Ages remain neutral;
+  reloads/config changes do not reroll stored plans.
+- Initial scoring covers Bright Lighting, Accelerated, Corrupted Pages, ineffective
+  Cave sky/weather modifiers, excess and biome-forced structures, and extra suns.
+  Corrupted Pages now bind successfully and retain their animated redacted text.
+- Ported 18 potion providers: local/global Blindness, Fatigue, Hunger, Nausea,
+  Poison, Slowness, Weakness and Wither, plus hostile Regeneration/Resistance.
+  General effects affect eligible Survival/Adventure players and living entities;
+  Creative/Spectator remain exempt. Local variants require sky exposure.
+- Added a bounded occupied-Age scheduler, owned-effect cleanup, provider controls
+  and operator score/status, enable/disable, session test-score and pulse commands.
+  Effects supplied or extended by another source are preserved.
+- Ported Blue, Purple, Red and White decay with the existing 16x16 textures,
+  hardness/air conversion odds, saved per-color frontiers and attempt sequence.
+  White retains stepping-contact magic damage. Decay has no item form or drops.
+- Spread uses only already-loaded candidate chunks, bounded attempts and action
+  budgets. Fluids, block entities, critical/unbreakable blocks, infrastructure,
+  protected tags and claim events prevent conversion.
+- The first resolved book/portal arrival is saved for spawn protection. Re-enter
+  an older Age once to record it. Global/Age/provider and world-mutation controls
+  gate spread; existing decay blocks remain when spreading is disabled.
+- Test a color with `/rivencraft_port instability decay blue 32` (also `purple`,
+  `red`, `white`); output includes actual changes and nearby tracked coordinates.
+  Scores are not added to ordinary book or Binder displays.
+
+## Validation and remaining work
+
+Player in-game checks passed .116–.120. Both the 26.3 and 1.21.1 builds passed;
+Gradle has no standalone test sources. Targeted disposable dedicated-server checks
+covered library placement, portal entity travel and restart ownership/cleanup,
+potion application/cleanup and persistence, all four decay colors, saved spread
+continuation, and bedrock/fluid protection. Test servers were stopped and their
+worlds removed.
+
+Full writing recovery/penalties, live material-abundance profiling, other instability
+hazards, remaining discovery/stations and optional integrations still need port work.
+Unported hazard cards remain saved and are reported as unavailable, rather than
+being replaced with different cards. Book previews remain the animated fallback.
+Machine acceleration (#112), Writing Desk model placement (#113), and the matching
+1.21.1 universal dropped-book fix (#114) remain tracked separately.
+
+Use matching client/server beta builds (catalog protocol 10). Keep Minecraft tracks
+and saves separate, back up beta worlds, and do not downgrade saves containing new
+blocks or data to earlier betas.

ports/mc263/RELEASE_NOTES_1.0.1.129-beta.1.md

@@ -0,0 +1,68 @@
+# Rivencraft 26.3 beta 1.0.1.129-beta.1
+
+Collects the player-validated .121–.129 port slices since 1.0.1.120-beta.1.
+For Minecraft 26.3, NeoForge 26.3.0.99 and Java 25. The independent Minecraft
+1.21.1 release is unchanged. Full parity and optional integrations remain in progress.
+
+## Instability hazards and live profiling
+
+- Ported lightning, explosions, falling meteor effects, burning and erosion with
+  bounded loaded-chunk scans, spawn protection, claim events and configurable
+  world/entity damage. Meteor flight uses the existing sound and particle effects.
+- Natural hazards choose randomized locations; operator test commands provide
+  targeted checks with independent cooldowns. Erosion retains its requested testing
+  default of enabled above 10,000 effective instability, outside the Legacy deck.
+- Ported persistent live material profiling, including native ores, valuable blocks,
+  recognized installed-mod materials and configurable modded block weight overrides.
+  No content mod is required. Profiling starts scoring after 401 Age and 500
+  Overworld baseline samples, with bounded gradual background sampling while an
+  eligible Age is occupied. A chunk snapshot is counted once.
+- Effective instability and deterministic provider selection now update as material
+  abundance is measured; the original writing contribution remains frozen. Added
+  difficulty scaling and operator-only sampling/score diagnostics. Older neutral
+  Ages remain neutral. Normal book/Binder screens do not reveal scores.
+
+## Ordered writing recovery
+
+- Repeated singular terrain, distribution, weather, lighting and sky controllers
+  use the last choice, adding 500 instability per duplicate/conflict. Category-order
+  mistakes add 100. Native distribution ignores supplied biomes; Single retains the
+  first biome when too many are supplied, with conflict penalties.
+- Repeated celestial modifiers use the final pending value of each kind. Dangling
+  modifiers and misplaced/trailing numbers allow binding and add 100 instability.
+  Numbers only attach to the immediately following supported target.
+- Preserved original book/library pages, ordered color mixing and independent
+  celestial chains. A trailing modifier cannot change an earlier sun or moon.
+  Unported pages, unsupported combinations and body limits remain enforced.
+
+## Link Modifier station
+
+- Added the creative-only Link Modifier with its existing model, textures and
+  Legacy single-book GUI. There is no crafting recipe.
+- Books can be renamed and edited through all six controls: Disarm, Intra-Linking,
+  Intra-Linking Only, Maintain Momentum, Relative Link and Generate Platform.
+- Intra-Linking Only enables Intra-Linking and prevents cross-dimension Linking
+  Book travel. Both intra controls are unavailable for Descriptive Books.
+- Relative Link preserves the traveller's offset from the source dimension spawn
+  at the destination spawn. Linking Book platform generation defaults off;
+  Descriptive Book fallback platforms default on and can be disabled.
+- Player and non-player portal paths share the new properties. Book contents and
+  flags persist in the station. Removal releases its stored book.
+- Fixed the controls ignoring real clicks: 26.3 left-click is button 1, not 0.
+  Registered native button widgets now handle input, focus, sound and state tooltips.
+
+## Validation and remaining work
+
+The player passed every included slice, including the six controls and click fix.
+Both Minecraft builds pass (no standalone Gradle test sources). Targeted temporary
+checks covered grammar/celestial recovery, component serialization, station actions,
+platform rules and dedicated-server save/restart behavior. Live profiling was checked
+with real snapshots plus synthetic threshold records; natural gameplay was validated
+by the player. Temporary servers were stopped and their test worlds removed.
+
+Link Modifier seed editing/retirement, remaining discovery/config policy and optional
+integrations are not complete. Live previews remain unavailable; books and portals
+use the animated fallback. Crumble has no active 1.21.1 handler and is not invented
+in this port. The dual-version follow-up issues and full multiplayer/parity gate
+remain open. Use matching client/server beta builds and keep Minecraft version
+tracks and their saves separate.

ports/mc263/RELEASE_NOTES_1.0.1.32-beta.1.md

@@ -0,0 +1,19 @@
+# Rivencraft 26.3 beta 1.0.1.32-beta.1
+
+This is the first 26.3 beta, focused on authored Age generation. It is not yet
+feature-complete with the separate Minecraft 1.21.1 release.
+
+- Ported the Book Binder's ordered symbol-page strip and Legacy-inspired GUI,
+  plus runtime symbol artwork, creative pages, and registry-derived biome pages.
+- Ported the Ink Mixer, its additive modifiers, and one-paper/one-ink-unit Link
+  Panel creation.
+- Added authored Standard, Amplified, and Island terrain; fixed, Tiled, Grid,
+  Native, and Tiny through Huge biome distributions; and persistent Age plans.
+- Fixed workstation block-face occlusion beside the Book Binder and Ink Mixer.
+
+Feature/material writing, Cave/Flat/Void terrain, portals, and other 1.21.1
+systems are still being ported. Use a test world and keep a backup. Minecraft
+1.21.1 saves are not supported by this beta.
+
+Requires Minecraft 26.3, NeoForge 26.3.0.99 or a compatible 26.3 build, and
+Java 25.

ports/mc263/RELEASE_NOTES_1.0.1.36-beta.1.md

@@ -0,0 +1,12 @@
+# Rivencraft 26.3 beta 1.0.1.36-beta.1
+
+This beta adds Flat and Void terrain to authored Ages on Minecraft 26.3.
+
+- Bind Descriptive Books with Flat or Void terrain, including multiple Biome pages and supported biome-distribution pages.
+- Flat ground starts at Y=0; travel lands on its surface rather than on an elevated fallback platform.
+- Flat Ages generate the selected biomes' surface decorations, including trees and vegetation. Void Ages remain empty while retaining authored biome climate.
+- Expanded dedicated-server checks for Flat and Void terrain, biome distribution, and persistence after restart.
+
+This 26.3 port is still experimental and does not yet include all features of the separate Minecraft 1.21.1 version. Use a test world and keep a backup. Minecraft 1.21.1 saves are not supported by this beta.
+
+Requires Minecraft 26.3, NeoForge 26.3.0.99 or a compatible 26.3 build, and Java 25.

ports/mc263/RELEASE_NOTES_1.0.1.39-beta.1.md

@@ -0,0 +1,14 @@
+# Rivencraft 26.3 beta 1.0.1.39-beta.1
+
+This beta adds Cave terrain to authored Ages on Minecraft 26.3.
+
+- Bind Descriptive Books with the Cave terrain page and Cave or Nether biome pages, including supported multi-biome distributions.
+- Cave Ages use the cave noise shape but remain dry by default. Newly generated chunks no longer flood below the vanilla cave sea level.
+- Cave travel searches from Y=64 downward for dry, properly footed space instead of landing on the cave roof or underwater.
+- Expanded dedicated-server checks for Cave creation, biome distribution, and persistence after restart.
+
+The player verified the Cave and safe-landing changes in game. Existing generated chunks are not drained or regenerated. A future Flooded page will provide an authored water level; see [issue #107](https://git.paddedcell.org/dnorberg/rivencraft/issues/107).
+
+This 26.3 port is still experimental and does not yet include all features of the separate Minecraft 1.21.1 version. Use a test world and keep a backup. Minecraft 1.21.1 saves are not supported by this beta.
+
+Requires Minecraft 26.3, NeoForge 26.3.0.99 or a compatible 26.3 build, and Java 25.

ports/mc263/RELEASE_NOTES_1.0.1.41-beta.1.md

@@ -0,0 +1,13 @@
+# Rivencraft 26.3 beta 1.0.1.41-beta.1
+
+This beta expands Age generation on Minecraft 26.3.
+
+- Descriptive Books with no authored symbol pages now choose a seeded random terrain and biome distribution. The chosen plan is saved with the Age and restored after restart.
+- A Block material page followed by a Rocks feature page now generates small clusters of that block in newly generated surface chunks. This first feature path supports Standard, Amplified, Island, and Flat terrain; Cave and Void combinations remain unsupported.
+- Expanded dedicated-server checks cover random Age plans and authored Rocks generation across restart.
+
+The player verified the Rocks feature in game. Random feature selection, duplicate feature pages, unpaired materials, and instability scoring are not yet ported. Existing chunks are not regenerated.
+
+This 26.3 port is still experimental and does not yet include all features of the separate Minecraft 1.21.1 version. Use a test world and keep a backup. Minecraft 1.21.1 saves are not supported by this beta.
+
+Requires Minecraft 26.3, NeoForge 26.3.0.99 or a compatible 26.3 build, and Java 25.

ports/mc263/RELEASE_NOTES_1.0.1.54-beta.1.md

@@ -0,0 +1,51 @@
+# Rivencraft 26.3 beta 1.0.1.54-beta.1
+
+This beta collects the player-validated Age feature port slices since
+1.0.1.41-beta.1. It is not yet feature-complete with Minecraft 1.21.1.
+
+## Age generation
+
+- Rocks now use the established 1.21.1 forest-rock placement. Unmodified
+  material-bearing features choose seeded materials independently; a preceding
+  compatible Block or Fluid page selects the material explicitly.
+- Added Flowers, Trees, Huge Trees, Dungeons, Surface Lakes, Deep Lakes, and
+  Small Lakes using the 1.21.1 placement rules adapted to 26.3.
+- Added Floating Islands, Tendrils, Skylands, Spheres, Spikes, and Obelisks
+  using the existing Rivencraft generation algorithms.
+- Added blue Crystal Formations with budding crystal and initially seeded buds.
+- Added Dense Ores: repeated pages replay eligible biome ore placements,
+  including compatible modded ores and explicitly tagged custom placements.
+- Added Star Fissures: one Legacy-shaped rift near the first arrival point,
+  a starfield at the dimension's minimum Y, and return travel to the shared
+  Overworld spawn with the original fissure sound. Cave roofs are preserved.
+- Feature plans, materials, repeated occurrences, and fissure completion
+  persist across restart. Existing generated chunks are not redecorated.
+
+## Current limits
+
+- Authored features retain terrain restrictions. Most repeated features allow
+  up to 32 occurrences; exceeding the current authoring cap blocks assembly.
+  Skylands and Star Fissures retain their single-effect behavior when repeated.
+- Put a material page immediately before a compatible feature. Dangling
+  material assignment, full Legacy grammar recovery, instability, and random
+  feature selection are not yet ported. Pageless books randomize terrain and
+  biome distribution, not the newly authored feature list.
+- 26.3 combines base terrain, surface, and carving. Added solid volumes run
+  after that combined operation and before decoration, so base carvers do not
+  cut those added volumes.
+- The full 1.21.1 writing/discovery loop, structures, environmental systems,
+  crystal portals, and optional integration parity remain in progress. The
+  presence of a Creative page is not a promise that its effect is ported.
+
+Build and static checks passed. The player reported in-game passes for these
+slices. Earlier server smoke coverage was expanded, but the later generation
+slices were manually validated; this release does not claim a new full
+dedicated-server regression pass.
+
+Requires Minecraft **26.3**, NeoForge **26.3.0.99** or a compatible 26.3 build,
+and **Java 25**. Dynamic Dimensions and Bad Packets are not required by this
+26.3 build. Do not use Minecraft 1.21.1 dependencies or saves with it. Back up
+the entire world before updating; beta-save compatibility is not guaranteed.
+
+Report issues and help with documentation at
+[BlackSheep Git](https://git.paddedcell.org/dnorberg/rivencraft).

ports/mc263/RELEASE_NOTES_1.0.1.65-beta.1.md

@@ -0,0 +1,72 @@
+# Rivencraft 26.3 beta 1.0.1.65-beta.1
+
+This beta collects the player-tested port slices since 1.0.1.54-beta.1.
+It is not yet feature-complete with the Minecraft 1.21.1 release.
+
+## Age generation
+
+- Added authored structure pages: Villages, Mineshafts, Strongholds, Trial
+  Chambers, Buried Treasure, Shipwrecks, Ocean Ruins, Pillager Outposts,
+  Ruined Portals, Nether Fossils, Ancient Cities, Trail Ruins, Nether
+  Fortresses, Bastions, and 26.3's Abandoned Camps. Dungeons remain their
+  separate feature.
+- Fixed the early structure-biome check so authored structures can generate
+  outside their native biome restrictions, within the supported terrain rules.
+  Repeated structure pages increase density up to the current authoring cap.
+- Added Caves and Ravines feature pages through 26.3's native carving stage.
+  These are distinct from Cave terrain; Flat/Void support remains pending.
+- Added Poplar Trees, Fallen Poplar Trees, Red Shrubs, and Shelf Mushrooms.
+  Shelf Mushrooms find exposed logs at any height, including log Tendrils in
+  Void terrain. No Trees page is required.
+- Added Normal, Fast, Slow, Off, Always, and Storm weather pages. Each Age
+  has independent saved weather data and timers; its policy does not change
+  the Overworld or other Ages. Cave terrain keeps weather disabled.
+
+## Fixes and feedback
+
+- Non-Cave Descriptive Book arrivals trace actual blocks down from maximum
+  build height instead of using a Flat-layer shortcut or only a heightmap.
+  The search stops at roofs/fluids rather than selecting underground pockets.
+  Leaves count as footing; submerged footing is rejected. Fallback platforms
+  sit above obstructions, with floor Y=63 in an empty Void.
+- Stored surface-Age Star Fissure arrivals are rechecked from above. Cave
+  terrain still searches down from Y=64, and Linking Books retain exact
+  bound destinations.
+- Restored Legacy linking sounds and successful-link cloud bursts. Disarm
+  and Intra-Linking use their respective sounds. Star Fissure return audio
+  also plays after arrival so a dimension switch does not discard it.
+- Fixed weather-only authoring, including Link Panel + Storm books: non-biome
+  pages no longer get interpreted as biome IDs.
+- Unsupported pages now have a red tint and availability tooltip. Supported
+  pages and their descriptions reflect the implemented 26.3 behavior.
+- Added operator weather and surface diagnostics for testing.
+
+## Current limits
+
+- Only the supported page/terrain combinations can be bound. Most repeated
+  features are capped at 32; vegetation uses a combined 32-page limit. The
+  full 1.21.1 grammar recovery and instability systems remain unported.
+- Pageless books currently randomize terrain and biome distribution, not the
+  complete feature/environment list. Omitted weather currently means Normal.
+- Base carvers do not carve authored solid volumes added after 26.3's combined
+  terrain operation. Previously generated chunks are not regenerated.
+- The full writing/discovery loop, celestial/lighting systems, crystal portals,
+  instability, and optional-integration parity remain in progress. Creative
+  availability alone does not mean a page is supported; check its tooltip.
+- Vanilla `/weather` targets global server weather, not the independent Age
+  policy. Biomes retain their normal precipitation rules.
+
+The player reported in-game passes for these slices. Build/static checks passed.
+Targeted disposable dedicated-server checks covered all six weather policies,
+Overworld isolation, unload/reload and restart persistence, weather-only page
+compilation, and dry surface/leaf spawn probes. This is not a claim of full
+dedicated-server or optional-mod regression coverage. Test servers were stopped
+and their temporary worlds removed.
+
+Requires Minecraft **26.3**, NeoForge **26.3.0.99** or a compatible 26.3 build,
+and **Java 25**. This build does not require Dynamic Dimensions or Bad Packets.
+Keep it separate from the 1.21.1 build and saves. Back up entire worlds before
+updating; beta-save compatibility is not guaranteed.
+
+Report issues and help improve the wiki at
+[BlackSheep Git](https://git.paddedcell.org/dnorberg/rivencraft).

ports/mc263/RELEASE_NOTES_1.0.1.71-beta.1.md

@@ -0,0 +1,59 @@
+# Rivencraft 26.3 beta 1.0.1.71-beta.1
+
+This beta collects the player-tested lighting and sky port slices since
+1.0.1.65-beta.1. It is not yet feature-complete with Minecraft 1.21.1.
+
+## Lighting and seeded environments
+
+- Added Normal, Dark, and Bright lighting pages with saved per-Age settings.
+- Bright works in Cave terrain too, without adding skylight or weather.
+- Bright supplies effective ambient light level 15 to native combined-light
+  checks and the white ambient rendering attribute. Vanilla darkness-based
+  monster checks respond to that lighting; there is no separate mob-spawn
+  veto. Mobs that ignore light retain their normal rules.
+- Missing weather and lighting controllers now resolve deterministically from
+  the Age seed, using independent choices and Legacy-style Normal weighting.
+  Explicit pages win; Cave terrain still forces weather Off. Existing Ages
+  keep their saved choices rather than rerolling on load.
+
+## Sky styles
+
+- Added Overworld, Nether, End, and animated Static Sky pages, independently
+  of terrain, weather, and lighting. Choices persist on reload and restart.
+- Nether Sky uses a reddish fog backdrop; End Sky uses the native End sky.
+  These are visual styles, not Nether/End terrain or gameplay conversions:
+  dimension geometry, coordinate scale, bed/water rules, and dragon behavior
+  are not changed.
+- Static Sky adapts the existing Legacy-style renderer: six independent
+  48×48 animated gray noise faces. A cached cube and small dynamic texture
+  avoid rebuilding thousands of per-cell vertices each frame. Client-only
+  rendering resources are released with the sky renderer.
+- Non-Overworld backgrounds have transparent clouds and a derived day
+  timeline that avoids Overworld sky/fog/cloud color tracks while retaining
+  gameplay and illumination schedules.
+- Updated supported-page feedback and added operator sky/environment probes.
+
+## Current limits and testing
+
+- Missing Sky pages still default to Overworld; random sky selection, color
+  pages and individual celestial bodies remain pending. Number-controlled
+  Static Sky resolution is tracked separately in issue #109 for both versions.
+- The writing/discovery loop, instability, portals, and optional-integration
+  parity are still incomplete. Creative availability is not a support claim;
+  check page tooltips and the beta guide for supported combinations.
+- Previously generated chunks are not regenerated. Save compatibility during
+  the beta is not guaranteed; keep backups and keep both version tracks apart.
+
+The player reported in-game passes for the included slices, including Static
+Sky. Build checks passed for both version tracks. Targeted disposable-server
+checks covered environment defaults, explicit choices, registered sky/lighting
+variants, persistence and restart, including Cave + Bright and Static Sky.
+This is not a claim of complete dedicated-server or optional-mod coverage.
+Test servers were stopped and temporary worlds removed.
+
+Requires Minecraft **26.3**, NeoForge **26.3.0.99** and **Java 25**. Dynamic
+Dimensions and Bad Packets are not required by this build. The 1.21.1 release
+and its dependencies are unchanged.
+
+Report issues and help improve the wiki at
+[BlackSheep Git](https://git.paddedcell.org/dnorberg/rivencraft).

ports/mc263/RELEASE_NOTES_1.0.1.78-beta.1.md

@@ -0,0 +1,53 @@
+# Rivencraft 26.3 beta 1.0.1.78-beta.1
+
+Collects the player-validated port slices since 1.0.1.71-beta.1. This beta is
+not yet feature-complete with the Minecraft 1.21.1 version.
+
+## Sky and color writing
+
+- Missing Sky pages now select a deterministic seeded style. Books with
+  Normal Time and no explicit Sky select celestial-compatible Overworld Sky.
+  Explicit Sky pages always win; weather and lighting choices stay independent.
+- Ported Red, Green, Blue, Black and White color pages. Preceding Number pages
+  control component strength; unnumbered colors use seeded values. Colors mix
+  before clamping the completed group. Colors before Sky tint that sky; a
+  trailing color group also targets the sky.
+- Added an Ambient Color controller for an independent ambient-light tint.
+  Color alone does not change effective illumination or monster-spawn rules.
+- Native, End and animated Static backgrounds use saved Age color settings.
+
+## Normal Time celestial controls
+
+- Length pages control the native day cycle; a preceding Number fine-tunes
+  length. Zero Length freezes the cycle at a seeded time or an authored Phase,
+  without interpolation bounce or changing the shared Overworld clock.
+- Rising, Zenith, Setting and Nadir Phase pages choose the starting phase.
+  Clockwise and Counterclockwise control direction. North, East, South and
+  West Angle pages choose orbit bearing. Preceding Number pages fine-tune
+  Phase and Angle in 15-degree increments.
+- Small, Normal and Large Celestial size Normal Time's sun to 0.5×, 1× and 2×.
+  A preceding Number overrides size from 0.25× to 3×. As in 1.21.1, the paired
+  moon remains normal-sized. Size does not alter illumination or day length.
+- Settings persist through reload/restart and remain stable when reseeding
+  future terrain. Older profiles retain native/default values.
+- Added operator diagnostics for environment, color and celestial profiles.
+
+## Compatibility and testing
+
+- Catalog protocol is now 6: use matching client/server builds.
+- Player in-game checks passed for the included slices. Build checks and
+  targeted disposable-server diagnostics covered numeric modifiers, catalog
+  round trips, unchanged sampled lighting, reload, reseed and restart.
+- Standalone Sun/Moon controllers, multiple bodies, per-body colors, eclipses,
+  full writing/discovery, instability, portals and optional-integration parity
+  remain incomplete. Creative availability does not imply full page support.
+- Number-controlled Static Sky resolution remains tracked in issue #109;
+  time-page naming improvements remain tracked in issue #110.
+- Existing chunks are not regenerated. Save compatibility is not guaranteed
+  during beta; keep backups and keep the two Minecraft version tracks apart.
+
+Requires Minecraft **26.3**, NeoForge **26.3.0.99**, and **Java 25**. Dynamic
+Dimensions and Bad Packets are not required. Minecraft 1.21.1 is unchanged.
+
+Report issues and help improve the wiki at
+[BlackSheep Git](https://git.paddedcell.org/dnorberg/rivencraft).

ports/mc263/RELEASE_NOTES_1.0.1.93-beta.1.md

@@ -0,0 +1,83 @@
+# Rivencraft 26.3 beta 1.0.1.93-beta.1
+
+Collects the player-validated port slices .79–.93 since 1.0.1.78-beta.1.
+This beta is not yet feature-complete with Minecraft 1.21.1.
+
+## Celestial writing and rendering
+
+- Ported standalone Sun and Moon pages and multiple independently authored
+  bodies, up to ten of each. Each controller consumes its own ordered Color,
+  Length, Phase, Direction, Angle and Size modifiers; Number pages fine-tune
+  supported values. Normal Time retains its paired sun/moon behavior.
+- Color groups before Normal Time tint both bodies; independent Sun/Moon
+  groups can use different colors. Authored moons use full-moon sprites as in
+  1.21.1; native Normal Time retains calendar moon phases.
+- Authored bodies render over Overworld, Nether, End and animated Static
+  backgrounds. Opaque centers retain transparent glows. Eclipse alignment
+  affects body color, background shading and gameplay sky light.
+- Bare Sun/Moon pages receive independent seeded colors, sizes, bearings,
+  phases, directions and lengths, including stopped cycles. Explicit modifier
+  groups retain their authored behavior.
+- Books without celestial controllers seed-complete 0–3 suns and 0–3 moons.
+  Empty skies do not accidentally draw a vanilla pair. Explicit controllers
+  suppress extra-body completion. Link-Panel-only random Ages also receive
+  seeded sky/fog colors using the 1.21.1 palette.
+- All resolved settings are saved, not rerolled by viewing a book, restarting,
+  or reseeding future terrain. Existing Age profiles remain unchanged.
+
+## Biome and feature completion
+
+- Explicit biome-distribution pages can now seed-complete missing biome
+  pools. Single selects one; other nonnative controllers require two distinct
+  biomes. Fully omitted pools use the seeded continuation rule, bounded by the
+  available biome pool. Authored pools fill only the missing minimum.
+- Supplied biome order and duplicate weights are retained. Two distinct
+  supplied biomes do not acquire an unwanted third biome. Cave pools use
+  recognized Cave/Nether biomes; Void does not inject The Void alongside
+  supplied biome pages.
+- Unpaired Block/Fluid pages receive seeded terrain-compatible implied
+  features. Consecutive materials resolve independently; explicit pairs remain
+  authoritative. Unsupported pairings and the current feature caps remain.
+- Link-Panel-only Ages roll 0–2 distinct material feature types with Legacy
+  rank weighting and compatible registered solids/source fluids. Additional
+  rare rolls cover Skylands, Crystal Formations and Star Fissures.
+- Random Ages also roll 0–2 distinct structure families, filtered by terrain,
+  registry availability and the chosen biome pool. Newer structures, including
+  26.3 Abandoned Camps, are rare candidates. An intentionally empty selection
+  disables page-controlled structure sets rather than enabling all of them.
+- Cave terrain now supports authored and randomly selected Dungeons, matching
+  1.21.1. Dungeon placement retains eight monster-room attempts per page and
+  modern build-height anchors. Flat/Void Dungeons and Cave lakes remain
+  unsupported.
+
+## Nether and End material correction
+
+- Ported 1.21.1's biome-specific material-rule layer for noise terrain. Nether
+  biomes in Cave Ages now use their native Netherrack, Nylium, Soul Sand/Soil,
+  Basalt and Blackstone rules instead of Overworld grass. End biomes use End
+  Stone. Other biomes retain the original terrain rules.
+- Geometry, biome selection, dry Cave aquifers and other environment settings
+  are preserved. Flat/Void layers and authored feature materials are unchanged.
+- Existing Ages pick up the correction after reload, but only new chunks
+  change. Already generated grass is not replaced.
+
+## Compatibility and validation
+
+- Requires Minecraft **26.3**, NeoForge **26.3.0.99**, and **Java 25**. Dynamic
+  Dimensions and Bad Packets are not required. Minecraft 1.21.1 is unchanged.
+- Catalog protocol is **10**: use matching client/server builds.
+- Player in-game checks passed for all included slices. Builds and targeted
+  disposable-server checks covered writing, seeded completion, codecs/catalog
+  round trips, terrain materials, reload, reseed and restart. Temporary servers
+  and test worlds were removed. This is not a full automated GameTest run.
+- Full writing recovery, discovery/stations, instability, portals and optional
+  integration parity remain unfinished. Random-page eligibility config also
+  remains pending; valuable/hazardous random materials currently lack the
+  finished version's instability scoring. Creative availability does not imply
+  full page support. Number-controlled Static resolution (#109) and time-page
+  naming (#110) remain separate work.
+- Beta save compatibility is not guaranteed. Back up worlds and keep the two
+  Minecraft version tracks and saves separate.
+
+Report issues and help improve the wiki at
+[BlackSheep Git](https://git.paddedcell.org/dnorberg/rivencraft).

ports/mc263/RELEASE_NOTES_1.0.1.98-beta.1.md

@@ -0,0 +1,63 @@
+# Rivencraft 26.3 beta 1.0.1.98-beta.1
+
+Collects the player-validated port slices .94–.98 since 1.0.1.93-beta.1.
+This beta is not yet feature-complete with Minecraft 1.21.1.
+
+## Seeded terrain and biome completion
+
+- Books without a Terrain page now choose terrain using the 1.21.1 weighted
+  selector. Incompatible choices are replaced with a seeded compatible terrain;
+  explicit Terrain pages retain their authored behavior.
+- Omitted biome controllers now use the seeded weighted distribution selector.
+  Supplied biome pages are retained, with missing minimum slots completed.
+  Void without biome pages still uses The Void. Link-Panel-only random Ages
+  retain their existing selection path.
+- Missing nonnative biome pools account for authored structures. Single chooses
+  a terrain-compatible biome satisfying all structure requirements where one
+  exists. Multiple-biome distributions add compatible biomes for unmet structure
+  requirements before completing their ordinary minimum. Explicit Single
+  choices are never replaced.
+- New Native Cave Ages freeze the full recognized Cave/Nether biome pool and
+  distribute it using seeded Tiny regions, matching the 1.21.1 implementation.
+  This includes recognized modded cave biomes. Existing empty Native Cave
+  profiles retain their previous Lush Caves fallback; explicit Single is unchanged.
+- Removing Nether-style biomes from the default Native Cave pool is separate
+  planned work for both versions in issue #111, not part of this release.
+
+## Accelerated pages
+
+- Ported the Accelerated environment page. Repeated pages stack, each adding
+  three extra random positions per eligible block section per tick near players.
+- Defaults match 1.21.1: at most eight already-loaded candidate chunks and
+  16,384 extra random-tick attempts per Age tick, shared fairly across sections.
+  No extra chunks are force-loaded.
+- Limits are configurable in `config/rivencraft-local.toml`, under
+  `accelerated_age`. A zero attempt budget disables the extra ticks.
+- Page counts persist across unload/reload, reseeding and restart. Existing
+  Ages default to zero. Pageless random Ages do not gain Accelerated automatically.
+- This currently affects random-ticking blocks such as crops and saplings.
+  Machine/block-entity acceleration is deferred for both versions under issue
+  #112; entities and scheduled block ticks are also unaffected. Instability
+  scoring remains part of the unfinished instability port.
+- Operator command `/rivencraft_port age acceleration <name>` reports the
+  saved page count and current budgets.
+
+## Compatibility and validation
+
+- Requires Minecraft **26.3**, NeoForge **26.3.0.99**, and **Java 25**. Dynamic
+  Dimensions and Bad Packets are not required. Minecraft 1.21.1 is unchanged.
+- Catalog protocol remains **10**. Use matching client/server builds.
+- Player in-game checks passed. Builds and targeted disposable-server checks
+  covered seeded completion, Native Cave sampling, tick-budget arithmetic,
+  unload/reload, reseeding and restart. Test servers were stopped and their
+  worlds removed. This was not a full automated GameTest run.
+- Back up worlds before updating. New populated Native Cave profiles cannot
+  be read by earlier beta builds; do not downgrade those saves. Keep Minecraft
+  1.21.1 and 26.3 saves separate.
+- Full writing recovery, discovery/stations, instability, crystal portals and
+  optional integration parity remain unfinished. Random-page eligibility config
+  and modded biome surface-rule integration also remain pending. Creative page
+  availability does not imply full support.
+
+Report issues and help improve the wiki at
+[BlackSheep Git](https://git.paddedcell.org/dnorberg/rivencraft).

ports/mc263/build.gradle

@@ -0,0 +1,314 @@
+plugins {
+    id 'java-library'
+    id 'net.neoforged.moddev' version '2.0.148'
+}
+
+group = 'net.dnorberg.rivencraft'
+version = mod_version
+
+base {
+    archivesName = "rivencraft-${minecraft_version}"
+}
+
+java.toolchain.languageVersion = JavaLanguageVersion.of(25)
+
+neoForge {
+    version = project.neo_version
+    runs {
+        client {
+            client()
+            if (project.hasProperty('connectAddress')) {
+                programArgument '--quickPlayMultiplayer'
+                programArgument project.property('connectAddress').toString()
+            }
+            if (project.hasProperty('clientName')) {
+                programArgument '--username'
+                programArgument project.property('clientName').toString()
+                gameDirectory = project.layout.buildDirectory.dir('run-client-' + project.property('clientName')).get().asFile
+            }
+        }
+        server {
+            server()
+            gameDirectory = project.hasProperty('serverRunDir')
+                    ? file(project.property('serverRunDir').toString())
+                    : project.layout.buildDirectory.dir('run-server').get().asFile
+            programArgument '--nogui'
+        }
+    }
+    mods {
+        rivencraft {
+            sourceSet(sourceSets.main)
+        }
+    }
+}
+
+def generateModMetadata = tasks.register('generateModMetadata', ProcessResources) {
+    def replaceProperties = [
+            mod_id: mod_id,
+            mod_name: mod_name,
+            mod_license: mod_license,
+            mod_version: mod_version,
+            neo_version: neo_version,
+            minecraft_version_range: minecraft_version_range,
+    ]
+    inputs.properties replaceProperties
+    expand replaceProperties
+    from 'src/main/templates'
+    into 'build/generated/sources/modMetadata'
+}
+sourceSets.main.resources.srcDir generateModMetadata
+neoForge.ideSyncTask generateModMetadata
+
+// Keep the bundled page list in step with the 1.21.1 symbol definitions.
+abstract class GeneratePortSymbolIndex extends DefaultTask {
+    @InputDirectory abstract DirectoryProperty getSymbolsDir()
+    @InputDirectory abstract DirectoryProperty getPortSymbolsDir()
+    @OutputDirectory abstract DirectoryProperty getIndexDir()
+
+    @TaskAction void generate() {
+        File root = symbolsDir.get().asFile
+        def definitions = new LinkedHashMap<String, Object>()
+        java.nio.file.Files.walk(root.toPath()).withCloseable { paths ->
+            paths.filter { java.nio.file.Files.isRegularFile(it) && it.toString().endsWith('.json') }
+                    .sorted().forEach { source ->
+                        String path = root.toPath().relativize(source).toString()
+                                .replace('\\', '/').replaceAll(/\.json$/, '')
+                        definitions["rivencraft:${path}"] = new groovy.json.JsonSlurper().parse(source.toFile())
+                    }
+        }
+        File portRoot = portSymbolsDir.get().asFile
+        java.nio.file.Files.walk(portRoot.toPath()).withCloseable { paths ->
+            paths.filter { java.nio.file.Files.isRegularFile(it) && it.toString().endsWith('.json') }
+                    .sorted().forEach { source ->
+                        String path = portRoot.toPath().relativize(source).toString()
+                                .replace('\\', '/').replaceAll(/\.json$/, '')
+                        definitions["rivencraft:${path}"] = new groovy.json.JsonSlurper().parse(source.toFile())
+                    }
+        }
+        File index = new File(indexDir.get().asFile, 'assets/rivencraft/creative_symbol_pages.json')
+        index.parentFile.mkdirs()
+        index.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(definitions)) + '\n'
+    }
+}
+
+def generatePortSymbolIndex = tasks.register('generatePortSymbolIndex', GeneratePortSymbolIndex) {
+    symbolsDir.set(layout.projectDirectory.dir('../../src/main/resources/data/rivencraft/rivencraft/symbols'))
+    portSymbolsDir.set(layout.projectDirectory.dir('src/main/resources/data/rivencraft/rivencraft/symbols'))
+    indexDir.set(layout.buildDirectory.dir('generated/resources/creativeSymbols'))
+}
+sourceSets.main.resources.srcDir generatePortSymbolIndex
+
+// Use the established symbol names/descriptions without overwriting 26.3-only strings.
+abstract class GeneratePortLanguage extends DefaultTask {
+    @InputFile abstract RegularFileProperty getBaseLanguage()
+    @InputFile abstract RegularFileProperty getPortLanguage()
+    @OutputDirectory abstract DirectoryProperty getOutputDir()
+
+    @TaskAction void generate() {
+        def base = new groovy.json.JsonSlurper().parse(baseLanguage.get().asFile) as Map
+        def port = new groovy.json.JsonSlurper().parse(portLanguage.get().asFile) as Map
+        base.putAll(port)
+        File result = new File(outputDir.get().asFile, 'assets/rivencraft/lang/en_us.json')
+        result.parentFile.mkdirs()
+        result.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(base)) + '\n'
+    }
+}
+
+def generatePortLanguage = tasks.register('generatePortLanguage', GeneratePortLanguage) {
+    baseLanguage.set(layout.projectDirectory.file('../../src/main/resources/assets/rivencraft/lang/en_us.json'))
+    portLanguage.set(layout.projectDirectory.file('port_en_us.json'))
+    outputDir.set(layout.buildDirectory.dir('generated/resources/portLanguage'))
+}
+sourceSets.main.resources.srcDir generatePortLanguage
+
+// Derive registered presentation variants without duplicating vanilla gameplay settings.
+abstract class GeneratePortDimensionTypes extends DefaultTask {
+    @InputFile abstract RegularFileProperty getMinecraftJar()
+    @OutputDirectory abstract DirectoryProperty getOutputDir()
+
+    @TaskAction void generate() {
+        new java.util.zip.ZipFile(minecraftJar.get().asFile).withCloseable { archive ->
+            def entry = archive.getEntry('data/minecraft/dimension_type/overworld.json')
+            if (entry == null) throw new GradleException('Missing vanilla Overworld dimension type')
+            String template = archive.getInputStream(entry).withCloseable { it.getText('UTF-8') }
+            def dayEntry = archive.getEntry('data/minecraft/timeline/day.json')
+            if (dayEntry == null) throw new GradleException('Missing vanilla day timeline')
+            def day = archive.getInputStream(dayEntry).withCloseable {
+                new groovy.json.JsonSlurper().parseText(it.getText('UTF-8'))
+            }
+            // Keep gameplay schedules and illumination, but do not tint these
+            // native non-Overworld sky backgrounds blue/black with the day cycle.
+            ['fog_color', 'sky_color', 'cloud_color'].each { day.tracks.remove("minecraft:visual/${it}".toString()) }
+            // Markers are global per clock and already owned by minecraft:day.
+            day.remove('time_markers')
+            File dayFile = new File(outputDir.get().asFile, 'data/rivencraft/timeline/age_sky_day.json')
+            dayFile.parentFile.mkdirs()
+            dayFile.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(day)) + '\n'
+            File timelineTag = new File(outputDir.get().asFile, 'data/rivencraft/tags/timeline/age_sky.json')
+            timelineTag.parentFile.mkdirs()
+            timelineTag.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson([
+                    values: ['#minecraft:universal', 'rivencraft:age_sky_day',
+                             'minecraft:moon', 'minecraft:early_game']])) + '\n'
+            ['overworld', 'nether', 'end', 'static'].each { sky ->
+                ['age_normal', 'age_dark', 'age_bright', 'age_cave_bright'].each { lighting ->
+                    if (sky == 'overworld' && lighting == 'age_normal') return
+                    String name = lighting + (sky == 'overworld' ? '' : "_sky_${sky}")
+                    def definition = new groovy.json.JsonSlurper().parseText(template)
+                    definition.has_skylight = lighting in ['age_normal', 'age_bright']
+                    definition.ambient_light = lighting in ['age_bright', 'age_cave_bright'] ? 1.0 : 0.0
+                    // 26.3's lightmap reads this attribute, not ambient_light.
+                    if (definition.ambient_light == 1.0)
+                        definition.attributes['minecraft:visual/ambient_light_color'] = '#ffffff'
+                    if (sky != 'overworld') {
+                        definition.skybox = sky == 'end' ? 'end' : 'none'
+                        definition.attributes['minecraft:visual/fog_color'] = sky == 'static' ? '#929292' : sky == 'end' ? '#181318' : '#6b2725'
+                        definition.attributes['minecraft:visual/sky_color'] = sky == 'static' ? '#929292' : sky == 'end' ? '#000000' : '#6b2725'
+                        definition.attributes['minecraft:visual/cloud_color'] = '#00000000'
+                        if (sky == 'nether') {
+                            definition.attributes['minecraft:visual/fog_start_distance'] = 10.0
+                            definition.attributes['minecraft:visual/fog_end_distance'] = 96.0
+                        }
+                        definition.timelines = '#rivencraft:age_sky'
+                    }
+                    File result = new File(outputDir.get().asFile, "data/rivencraft/dimension_type/${name}.json")
+                    result.parentFile.mkdirs()
+                    result.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(definition)) + '\n'
+                }
+            }
+        }
+    }
+}
+
+def generatePortDimensionTypes = tasks.register('generatePortDimensionTypes', GeneratePortDimensionTypes) {
+    dependsOn 'createMinecraftArtifacts'
+    minecraftJar.set(layout.buildDirectory.file("moddev/artifacts/minecraft-patched-${neo_version}.jar"))
+    outputDir.set(layout.buildDirectory.dir('generated/resources/dimensionTypes'))
+}
+sourceSets.main.resources.srcDir generatePortDimensionTypes
+
+tasks.named('processResources', ProcessResources).configure {
+    // Reuse the existing sprite and base model without copying binary assets.
+    from('../../src/main/resources') {
+        include 'data/rivencraft/worldgen/structure_set/fortresses.json'
+        include 'data/rivencraft/worldgen/structure_set/bastions.json'
+        include 'assets/rivencraft/models/block/star_fissure.json'
+        include 'assets/rivencraft/blockstates/star_fissure.json'
+        include 'assets/rivencraft/blockstates/decay.json'
+        include 'assets/rivencraft/models/block/decay_*.json'
+        include 'assets/rivencraft/textures/block/decay_*.png'
+        include 'data/rivencraft/tags/block/decay_protected.json'
+        include 'assets/rivencraft/sounds.json'
+        include 'assets/rivencraft/sounds/**/*.ogg'
+        include 'assets/rivencraft/textures/item/crystal_shard.png'
+        include 'assets/rivencraft/textures/item/page.png'
+        include 'assets/rivencraft/textures/item/page_link_panel.png'
+        include 'assets/rivencraft/textures/item/page_symbol.png'
+        include 'assets/rivencraft/models/item/page_symbol.json'
+        include 'assets/rivencraft/textures/gui/symbolcomponents.png'
+        include 'assets/rivencraft/models/item/page_link_panel.json'
+        include 'assets/rivencraft/textures/item/ink_vial.png'
+        include 'assets/rivencraft/textures/item/notebook.png'
+        include 'assets/rivencraft/textures/item/collation_folder.png'
+        include 'assets/rivencraft/models/item/notebook.json'
+        include 'assets/rivencraft/models/item/collation_folder.json'
+        include 'assets/rivencraft/textures/item/sealed_notebook.png'
+        include 'assets/rivencraft/textures/item/symbol_portfolio.png'
+        include 'assets/rivencraft/models/item/sealed_notebook.json'
+        include 'assets/rivencraft/models/item/symbol_portfolio.json'
+        include 'assets/rivencraft/textures/item/writing_desk.png'
+        include 'assets/rivencraft/textures/block/writing_desk.png'
+        include 'assets/rivencraft/textures/gui/writing_desk_legacy.png'
+        include 'assets/rivencraft/textures/gui/scrollbar.png'
+        include 'assets/rivencraft/models/item/writing_desk.json'
+        include 'assets/rivencraft/models/block/writing_desk.json'
+        include 'assets/rivencraft/models/block/writing_desk_extension.json'
+        include 'assets/rivencraft/blockstates/writing_desk.json'
+        include 'data/rivencraft/loot_table/blocks/writing_desk.json'
+        include 'data/rivencraft/advancement/progression/*.json'
+        exclude 'data/rivencraft/advancement/progression/root.json'
+        include 'assets/rivencraft/textures/item/ink_vial.png.mcmeta'
+        include 'assets/rivencraft/models/item/ink_vial.json'
+        include 'assets/rivencraft/models/item/crystal_shard.json'
+        include 'assets/rivencraft/textures/item/descriptive_book.png'
+        include 'assets/rivencraft/models/item/descriptive_book.json'
+        include 'assets/rivencraft/textures/item/linking_book.png'
+        include 'assets/rivencraft/textures/item/linking_book_unwritten.png'
+        include 'assets/rivencraft/models/item/linking_book_bound.json'
+        include 'assets/rivencraft/textures/gui/bookui_cover.png'
+        include 'assets/rivencraft/textures/gui/notebook_pages.png'
+        include 'assets/rivencraft/textures/gui/bookui_pager.png'
+        include 'assets/rivencraft/textures/gui/bookui_rpage_full.png'
+        include 'assets/rivencraft/textures/block/crystal_block.png'
+        include 'assets/rivencraft/textures/entity/linking_book.png'
+        include 'assets/rivencraft/textures/entity/descriptive_book.png'
+        include 'assets/rivencraft/textures/block/book_binder.png'
+        include 'assets/rivencraft/textures/block/book_binder_press.png'
+        include 'assets/rivencraft/textures/gui/book_binder_legacy.png'
+        include 'assets/rivencraft/textures/gui/link_modifier_legacy.png'
+        include 'assets/rivencraft/textures/block/link_modifier_*.png'
+        include 'assets/rivencraft/models/block/link_modifier.json'
+        include 'assets/rivencraft/models/item/link_modifier.json'
+        include 'assets/rivencraft/blockstates/link_modifier.json'
+        include 'data/rivencraft/loot_table/blocks/link_modifier.json'
+        include 'assets/rivencraft/textures/gui/ink_mixer_legacy.png'
+        include 'assets/rivencraft/textures/block/inkwell_base.png'
+        include 'assets/rivencraft/textures/block/inkwell_cup.png'
+        include 'assets/rivencraft/textures/block/ink.png'
+        include 'assets/rivencraft/textures/block/ink_glass.png'
+        include 'assets/rivencraft/models/block/ink_mixer.json'
+        include 'assets/rivencraft/models/item/ink_mixer.json'
+        include 'assets/rivencraft/blockstates/ink_mixer.json'
+        include 'data/rivencraft/loot_table/blocks/ink_mixer.json'
+        include 'assets/rivencraft/models/block/book_binder.json'
+        include 'assets/rivencraft/models/item/book_binder.json'
+        include 'assets/rivencraft/blockstates/book_binder.json'
+        include 'assets/rivencraft/blockstates/book_receptacle.json'
+        include 'assets/rivencraft/blockstates/crystal_portal.json'
+        include 'assets/rivencraft/models/block/book_receptacle.json'
+        include 'assets/rivencraft/models/block/crystal_portal.json'
+        include 'assets/rivencraft/models/item/book_receptacle.json'
+        include 'assets/rivencraft/textures/block/book_receptacle.png'
+        include 'assets/rivencraft/textures/block/crystal_portal.png'
+        include 'assets/rivencraft/textures/block/crystal_portal.png.mcmeta'
+        include 'data/rivencraft/loot_table/blocks/book_receptacle.json'
+        include 'assets/rivencraft/blockstates/book_stand.json'
+        include 'data/rivencraft/loot_table/blocks/book_stand.json'
+        include 'data/rivencraft/loot_table/chests/mystcraft_library.json'
+        include 'data/rivencraft/structure/mystcraft_library.nbt'
+        include 'data/rivencraft/loot_table/blocks/book_binder.json'
+        include 'assets/rivencraft/models/block/crystal_block.json'
+        include 'assets/rivencraft/blockstates/crystal_block.json'
+        include 'assets/rivencraft/models/block/cloud_platform.json'
+        include 'assets/rivencraft/blockstates/cloud_platform.json'
+        include 'assets/rivencraft/blockstates/budding_crystal.json'
+        include 'assets/rivencraft/blockstates/small_crystal_bud.json'
+        include 'assets/rivencraft/blockstates/medium_crystal_bud.json'
+        include 'assets/rivencraft/blockstates/large_crystal_bud.json'
+        include 'assets/rivencraft/blockstates/crystal_cluster.json'
+        include 'assets/rivencraft/models/block/budding_crystal.json'
+        include 'assets/rivencraft/models/block/small_crystal_bud.json'
+        include 'assets/rivencraft/models/block/medium_crystal_bud.json'
+        include 'assets/rivencraft/models/block/large_crystal_bud.json'
+        include 'assets/rivencraft/models/block/crystal_cluster.json'
+        include 'assets/rivencraft/models/item/budding_crystal.json'
+        include 'assets/rivencraft/models/item/small_crystal_bud.json'
+        include 'assets/rivencraft/models/item/medium_crystal_bud.json'
+        include 'assets/rivencraft/models/item/large_crystal_bud.json'
+        include 'assets/rivencraft/models/item/crystal_cluster.json'
+        include 'assets/rivencraft/textures/block/small_crystal_bud.png'
+        include 'assets/rivencraft/textures/block/medium_crystal_bud.png'
+        include 'assets/rivencraft/textures/block/large_crystal_bud.png'
+        include 'assets/rivencraft/textures/block/crystal_cluster.png'
+        include 'data/rivencraft/loot_table/blocks/crystal_block.json'
+        include 'data/minecraft/tags/block/mineable/pickaxe.json'
+        include 'data/minecraft/tags/item/cluster_max_harvestables.json'
+    }
+}
+
+tasks.withType(JavaCompile).configureEach {
+    options.encoding = 'UTF-8'
+}
+
+tasks.named('runServer').configure {
+    standardInput = System.in
+}

ports/mc263/gradle.properties

@@ -0,0 +1,10 @@
+org.gradle.jvmargs=-Xmx2G
+org.gradle.caching=true
+
+minecraft_version=26.3
+minecraft_version_range=[26.3]
+neo_version=26.3.0.99
+mod_id=rivencraft
+mod_name=Rivencraft
+mod_license=LGPL-3.0-or-later
+mod_version=1.0.1.129-beta.1

ports/mc263/port_en_us.json

@@ -0,0 +1,110 @@
+{
+  "item.rivencraft.crystal_shard": "Crystal Shard",
+  "item.rivencraft.descriptive_book": "Descriptive Book",
+  "item.rivencraft.linking_book": "Linking Book",
+  "item.rivencraft.page": "Page",
+  "item.rivencraft.page.blank": "Blank Page",
+  "item.rivencraft.page.link_panel": "Link Panel Page",
+  "item.rivencraft.page.unresolved": "Unknown Symbol Page",
+  "item.rivencraft.page.symbol.implemented": "Implemented in 26.3; book and terrain requirements still apply.",
+  "symbol.rivencraft.weather.normal.description": "Use an independent normal weather cycle. Cave terrain keeps weather off.",
+  "symbol.rivencraft.sky.overworld.description": "Use the native Overworld sky. Terrain and lighting remain independently authored.",
+  "symbol.rivencraft.sky.nether.description": "Use a Nether-style reddish fog backdrop. Authored celestials render over it; terrain and gameplay rules remain independent.",
+  "symbol.rivencraft.sky.end.description": "Use the native End sky backdrop with authored celestials over it, without End terrain or a dragon fight.",
+  "symbol.rivencraft.sky.static.description": "Animated static surrounds the Age, behind authored celestials. Preceding colors tint it; otherwise it is gray.",
+  "symbol.rivencraft.lighting.ambient_color": "Ambient Light Color",
+  "symbol.rivencraft.lighting.ambient_color.description": "Apply preceding shared colors to ambient light. Use Bright separately for full effective ambient lighting.",
+  "symbol.rivencraft.number.description": "Before Color: value × 10 per channel. Before Length: value × 0.08 days. Before Phase/Angle: value × 15 degrees. Before Size: 0.25× to 3× (0-24).",
+  "symbol.rivencraft.size.small.description": "Before Sun/Moon: 0.5× body size. Before Normal Time: size the sun only. A preceding Number overrides the size.",
+  "symbol.rivencraft.size.normal.description": "Before Sun/Moon: 1× body size. Before Normal Time: size the sun only. A preceding Number selects 0.25× through 3× (0-24).",
+  "symbol.rivencraft.size.large.description": "Before Sun/Moon: 2× body size. Before Normal Time: size the sun only. A preceding Number selects 0.25× through 3× (0-24).",
+  "symbol.rivencraft.angle.north.description": "Before Normal Time, Sun or Moon: set orbit bearing to 0 degrees. A preceding Number overrides Angle in 15-degree steps.",
+  "symbol.rivencraft.angle.east.description": "Before Normal Time, Sun or Moon: set orbit bearing to 90 degrees. A preceding Number overrides Angle in 15-degree steps.",
+  "symbol.rivencraft.angle.south.description": "Before Normal Time, Sun or Moon: set orbit bearing to 180 degrees. A preceding Number overrides Angle in 15-degree steps.",
+  "symbol.rivencraft.angle.west.description": "Before Normal Time, Sun or Moon: set orbit bearing to 270 degrees. A preceding Number overrides Angle in 15-degree steps.",
+  "symbol.rivencraft.phase.rising.description": "Before a celestial controller: start the sun or standalone moon at rising. A preceding Number overrides Phase in 15-degree steps from Nadir.",
+  "symbol.rivencraft.phase.zenith.description": "Before a celestial controller: start the sun or standalone moon overhead. Zero Length holds this position.",
+  "symbol.rivencraft.phase.setting.description": "Before a celestial controller: start the sun or standalone moon at setting. A preceding Number overrides Phase in 15-degree steps from Nadir.",
+  "symbol.rivencraft.phase.nadir.description": "Before a celestial controller: start the sun or standalone moon below the world. Zero Length holds this position.",
+  "symbol.rivencraft.direction.clockwise.description": "Before Normal Time, Sun or Moon: advance this Age's celestial cycle in its usual direction.",
+  "symbol.rivencraft.direction.counterclockwise.description": "Before Normal Time, Sun or Moon: reverse this Age's celestial cycle. Does not change the Overworld clock.",
+  "symbol.rivencraft.celestial.normal_time.description": "Add a sun/moon pair. Preceding modifiers apply to this pair; Size affects its sun only. Colors tint both. Limit ten suns and ten moons per Age.",
+  "symbol.rivencraft.celestial.sun.description": "Add a sun. A bare page gets saved seeded color, size and orbit controls. Written modifiers preserve authored behavior and reset per controller. Moon alignment causes eclipses; limit ten suns.",
+  "symbol.rivencraft.celestial.moon.description": "Add a moon with weaker light. A bare page gets saved seeded color, size and orbit controls. Written modifiers preserve authored behavior and reset per controller. Sun alignment causes eclipses; limit ten moons.",
+  "symbol.rivencraft.period.zero.description": "Before Normal Time, Sun or Moon: freeze at the written Phase, or a saved seeded time if omitted. A preceding Number overrides the Length.",
+  "symbol.rivencraft.period.half.description": "Before Normal Time, Sun or Moon: a half-length cycle (twice as fast). A preceding Number sets Length to value × 0.08 days.",
+  "symbol.rivencraft.period.full.description": "Before Normal Time, Sun or Moon: a normal-length cycle. A preceding Number sets Length to value × 0.08 days.",
+  "symbol.rivencraft.period.double.description": "Before Normal Time, Sun or Moon: a double-length cycle (half as fast). A preceding Number sets Length to value × 0.08 days.",
+  "symbol.rivencraft.color.red.description": "Add red to the next Sky, Ambient Light Color or celestial controller; trailing colors tint the sky. Precede with a Number, or use a seeded amount.",
+  "symbol.rivencraft.color.green.description": "Add green to the next Sky, Ambient Light Color or celestial controller; trailing colors tint the sky. Precede with a Number, or use a seeded amount.",
+  "symbol.rivencraft.color.blue.description": "Add blue to the next Sky, Ambient Light Color or celestial controller; trailing colors tint the sky. Precede with a Number, or use a seeded amount.",
+  "symbol.rivencraft.color.white.description": "Add equally to all RGB channels. Precede with a Number, or use a seeded amount.",
+  "symbol.rivencraft.color.black.description": "Subtract equally from all RGB channels. Precede with a Number, or use a seeded amount.",
+  "symbol.rivencraft.lighting.normal.description": "Use normal skylight and ambient brightness. Cave terrain remains without skylight.",
+  "symbol.rivencraft.lighting.dark.description": "Remove skylight from this Age; placed light sources still work.",
+  "symbol.rivencraft.lighting.bright.description": "Provide full ambient brightness and effective light level 15. Vanilla light-based spawn rules apply, including in Cave terrain without skylight.",
+  "symbol.rivencraft.weather.fast.description": "Use the faster Legacy weather cycle in this Age only. Cave terrain keeps weather off.",
+  "symbol.rivencraft.weather.slow.description": "Use the slower Legacy weather cycle in this Age only. Cave terrain keeps weather off.",
+  "symbol.rivencraft.weather.off.description": "Keep this Age clear without changing Overworld weather.",
+  "symbol.rivencraft.weather.always.description": "Keep this Age rainy, or snowy in cold biomes, without thunder. Cave terrain keeps weather off.",
+  "symbol.rivencraft.weather.storm.description": "Keep this Age rainy and thundering. Precipitation still depends on the biome; Cave terrain keeps weather off.",
+  "item.rivencraft.page.symbol.unimplemented": "Not yet implemented in 26.3; cannot be bound into an Age.",
+  "item.rivencraft.link_property.disarm": "Disarm",
+  "item.rivencraft.link_property.maintain_momentum": "Maintain Momentum",
+  "item.rivencraft.link_property.intra_linking": "Intra-Linking",
+  "item.rivencraft.ink_vial": "Ink Vial",
+  "item.rivencraft.ink_vial.remaining": "Ink: %s/%s",
+  "item.rivencraft.ink_vial.usage": "Use with paper in the other hand, or place in an Ink Mixer.",
+  "item.rivencraft.page.blank.port_status": "Internal symbol-page base; not an authoring ingredient.",
+  "item.rivencraft.page.link_panel.port_status": "Use with leather in a Book Binder to make a Descriptive Book.",
+  "block.rivencraft.book_binder": "Book Binder",
+  "container.rivencraft.book_binder": "Book Binder",
+  "screen.rivencraft.book_binder.missing_panel": "Link Panel required",
+  "screen.rivencraft.book_binder.authored_pending": "Unsupported page or page combination",
+  "block.rivencraft.ink_mixer": "Ink Mixer",
+  "container.rivencraft.ink_mixer": "Ink Mixer",
+  "screen.rivencraft.ink_mixer.ink": "Ink: %s/%s",
+  "screen.rivencraft.ink_mixer.additive_hint": "Click with an additive to mix it in",
+  "screen.rivencraft.ink_mixer.chance": "%s: %s%%",
+  "block.rivencraft.crystal_block": "Crystal Block",
+  "block.rivencraft.budding_crystal": "Budding Crystal",
+  "block.rivencraft.small_crystal_bud": "Small Crystal Bud",
+  "block.rivencraft.medium_crystal_bud": "Medium Crystal Bud",
+  "block.rivencraft.large_crystal_bud": "Large Crystal Bud",
+  "block.rivencraft.crystal_cluster": "Crystal Cluster",
+  "itemGroup.rivencraft": "Rivencraft",
+  "itemGroup.rivencraft.pages.link": "Rivencraft Link Pages",
+  "symbol.rivencraft.feature.poplar_trees": "Poplar Trees",
+  "symbol.rivencraft.feature.poplar_trees.description": "Add red, orange, and yellow poplar trees to surface terrain with suitable soil.",
+  "symbol.rivencraft.feature.fallen_poplar_trees": "Fallen Poplar Trees",
+  "symbol.rivencraft.feature.fallen_poplar_trees.description": "Add fallen poplar logs and stumps to surface terrain with suitable soil.",
+  "symbol.rivencraft.feature.shelf_mushrooms": "Shelf Mushrooms",
+  "symbol.rivencraft.feature.shelf_mushrooms.description": "Add shelf mushrooms to exposed log faces on any terrain, including Void. No tree page is required.",
+  "symbol.rivencraft.feature.red_shrubs": "Red Shrubs",
+  "symbol.rivencraft.feature.red_shrubs.description": "Add red shrub patches to surface terrain with suitable ground.",
+  "symbol.rivencraft.feature.abandoned_camps": "Abandoned Camps",
+  "symbol.rivencraft.feature.abandoned_camps.description": "Allow abandoned camps on surface noise terrain, including outside their usual biomes.",
+  "symbol.rivencraft.block.generated.description": "Modify the next compatible feature. Without a following feature, choose a compatible feature from the Age seed.",
+  "symbol.rivencraft.biome.native.description": "Use the terrain's default biome source. Cave uses Tiny regions from recognized Cave/Nether biomes. Do not include Biome pages.",
+  "symbol.rivencraft.feature.dungeons.description": "Add monster-room dungeon attempts throughout surface noise or Cave terrain, including Nether cave biomes. Not Flat or Void.",
+  "symbol.rivencraft.biome.single.description": "Use one biome across the Age. If omitted, choose an eligible biome from the Age seed.",
+  "symbol.rivencraft.terrain.flat.description": "A level, biome-decorated landscape with its foundation at Y=0.",
+  "symbol.rivencraft.environment.accelerated.description": "Adds extra random block ticks near players in this Age. Repeated pages stack within server tick budgets; does not speed up entities or machines.",
+  "symbol.rivencraft.feature.floating_islands.description": "Add high floating islands alongside noise, Flat, or Void terrain; not Cave terrain.",
+  "symbol.rivencraft.feature.caves.description": "Add extra cave carving to noise terrain, including Cave; not Flat or Void.",
+  "symbol.rivencraft.feature.ravines.description": "Add canyon carving to noise terrain; not Flat or Void. Skips Nether biomes.",
+  "symbol.rivencraft.feature.mineshafts.description": "Allow mineshafts in noise terrain, including Cave, regardless of normal biome eligibility.",
+  "symbol.rivencraft.feature.nether_fortresses.description": "Allow Nether fortresses in Cave terrain; the authored page overrides biome eligibility.",
+  "symbol.rivencraft.feature.strongholds.description": "Allow strongholds in surface noise or Flat terrain, including outside their usual biomes.",
+  "symbol.rivencraft.feature.villages.description": "Allow villages in surface noise or Flat terrain, including outside their usual biomes.",
+  "symbol.rivencraft.feature.trial_chambers.description": "Allow underground Trial Chambers in noise terrain, including Cave, regardless of biome eligibility.",
+  "symbol.rivencraft.feature.bastions.description": "Allow Bastion Remnants in Cave terrain; the authored page overrides biome eligibility.",
+  "symbol.rivencraft.feature.buried_treasure.description": "Allow buried treasure in surface noise terrain; biome eligibility is overridden, but suitable terrain is required.",
+  "symbol.rivencraft.feature.shipwrecks.description": "Allow shipwrecks in surface noise terrain, including outside their usual ocean and beach biomes.",
+  "symbol.rivencraft.feature.ocean_ruins.description": "Allow ocean ruins in surface noise terrain, including outside their usual biomes.",
+  "symbol.rivencraft.feature.pillager_outposts.description": "Allow pillager outposts in surface noise terrain, including outside their usual biomes.",
+  "symbol.rivencraft.feature.ruined_portals.description": "Allow ruined portals in noise terrain, including Cave, regardless of normal biome eligibility.",
+  "symbol.rivencraft.feature.nether_fossils.description": "Allow Nether fossils in Cave terrain; the authored page overrides biome eligibility.",
+  "symbol.rivencraft.feature.ancient_cities.description": "Allow underground Ancient Cities in noise terrain, including Cave, regardless of biome eligibility.",
+  "symbol.rivencraft.feature.trail_ruins.description": "Allow Trail Ruins in surface noise terrain, including outside their usual biomes."
+}

ports/mc263/settings.gradle

@@ -0,0 +1,11 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id 'org.gradle.toolchains.foojay-resolver-convention' version '1.0.0'
+}
+
+rootProject.name = 'rivencraft-mc263-port'

ports/mc263/src/main/java/net/dnorberg/rivencraft/PortConfig.java

@@ -0,0 +1,46 @@
+package net.dnorberg.rivencraft;
+
+import net.neoforged.neoforge.common.ModConfigSpec;
+
+/** Server-owned gameplay policies adapted from 1.21.1. */
+public final class PortConfig {
+    public enum LibraryLootMode { LEGACY, AGE_ONLY }
+    public static final ModConfigSpec.EnumValue<LibraryLootMode> LIBRARY_LOOT_MODE;
+    public enum ReturnLinkMode { ON_CREATION, ALWAYS, DISABLED }
+    public static final ModConfigSpec SPEC;
+    public static final ModConfigSpec.IntValue SYMBOL_INK_COST;
+    public static final ModConfigSpec.IntValue LINK_PANEL_INK_COST;
+    public static final ModConfigSpec.EnumValue<ReturnLinkMode> RETURN_LINK_MODE;
+    public static final ModConfigSpec.IntValue ACCELERATED_MAX_CHUNKS;
+    public static final ModConfigSpec.IntValue ACCELERATED_MAX_ATTEMPTS;
+
+    static {
+        var builder = new ModConfigSpec.Builder();
+        builder.push("descriptive_books");
+        RETURN_LINK_MODE = builder.comment("Controls automatic Return Links for successful Descriptive Book travel.",
+                "ON_CREATION issues one on the first arrival per Age/world; ALWAYS issues one each arrival; DISABLED issues none.")
+                .defineEnum("return_link_mode", ReturnLinkMode.DISABLED);
+        builder.pop();
+        builder.push("libraries");
+        LIBRARY_LOOT_MODE = builder.comment("LEGACY uses writing supplies/Sealed Notebooks and random lectern pages; AGE_ONLY uses only pages written into this Age.")
+                .defineEnum("loot_mode", LibraryLootMode.LEGACY);
+        builder.pop();
+        builder.push("writing");
+        SYMBOL_INK_COST = builder.comment("Ink units consumed for one Writing Desk symbol copy.")
+                .defineInRange("symbol_ink_cost", 1, 1, 16);
+        LINK_PANEL_INK_COST = builder.comment("Ink units consumed when preparing one baseline Link Panel by hand with paper.",
+                "The Ink Mixer uses one ink unit per panel independently of this setting.")
+                .defineInRange("link_panel_ink_cost", 2, 1, 16);
+        builder.pop();
+        builder.push("accelerated_age");
+        ACCELERATED_MAX_CHUNKS = builder.comment("Maximum already-loaded player-nearby chunks given extra random ticks per Age tick.")
+                .defineInRange("max_loaded_chunks", 8, 1, 64);
+        ACCELERATED_MAX_ATTEMPTS = builder.comment("Maximum extra random-tick positions sampled per Age tick, shared fairly across loaded sections; zero disables Accelerated.")
+                .defineInRange("max_random_tick_attempts_per_tick", 16384, 0, 65536);
+        builder.pop();
+        net.dnorberg.rivencraft.age.PortInstabilityConfig.define(builder);
+        SPEC = builder.build();
+    }
+
+    private PortConfig() {}
+}

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

@@ -0,0 +1,271 @@
+package net.dnorberg.rivencraft;
+
+import com.mojang.logging.LogUtils;
+import com.mojang.serialization.Codec;
+import net.dnorberg.rivencraft.age.RuntimeAgeBackend;
+import net.dnorberg.rivencraft.age.PortAgeCommands;
+import net.dnorberg.rivencraft.age.AgeCatalogSync;
+import net.dnorberg.rivencraft.block.BuddingCrystalBlock;
+import net.dnorberg.rivencraft.block.PortBookBinderBlock;
+import net.dnorberg.rivencraft.block.InkMixerBlock;
+import net.dnorberg.rivencraft.block.StarFissureBlock;
+import net.dnorberg.rivencraft.block.entity.StarFissureBlockEntity;
+import net.dnorberg.rivencraft.block.entity.PortBookBinderBlockEntity;
+import net.dnorberg.rivencraft.block.entity.InkMixerBlockEntity;
+import net.dnorberg.rivencraft.menu.PortBookBinderMenu;
+import net.dnorberg.rivencraft.menu.InkMixerMenu;
+import net.dnorberg.rivencraft.item.DescriptiveBookItem;
+import net.dnorberg.rivencraft.item.LinkBookTarget;
+import net.dnorberg.rivencraft.item.LinkProperties;
+import net.dnorberg.rivencraft.item.InkVialItem;
+import net.dnorberg.rivencraft.item.LinkingBookItem;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.network.PortBookNetworking;
+import net.dnorberg.rivencraft.registry.ModCreativeTabs;
+import net.dnorberg.rivencraft.registry.PortBiomeSources;
+import net.dnorberg.rivencraft.registry.PortChunkGenerators;
+import net.dnorberg.rivencraft.writing.LinkingBookRecipe;
+import net.minecraft.core.component.DataComponentType;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.AmethystClusterBlock;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.material.MapColor;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.neoforged.bus.api.IEventBus;
+import net.neoforged.fml.common.Mod;
+import net.neoforged.neoforge.registries.DeferredBlock;
+import net.neoforged.neoforge.registries.DeferredItem;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.common.extensions.IMenuTypeExtension;
+import java.util.function.Supplier;
+import net.neoforged.neoforge.common.NeoForge;
+import org.slf4j.Logger;
+
+/** First 26.3 registry slice; gameplay remains in the 1.21.1 target for now. */
+@Mod(Rivencraft.MOD_ID)
+public final class Rivencraft {
+    public static final String MOD_ID = "rivencraft";
+    public static final Logger LOGGER = LogUtils.getLogger();
+    private static final DeferredRegister.Blocks BLOCKS = DeferredRegister.createBlocks(MOD_ID);
+    private static final DeferredRegister.Items ITEMS = DeferredRegister.createItems(MOD_ID);
+    private static final DeferredRegister<net.minecraft.world.entity.EntityType<?>> ENTITIES =
+            DeferredRegister.create(Registries.ENTITY_TYPE, MOD_ID);
+    public static final Supplier<net.minecraft.world.entity.EntityType<net.dnorberg.rivencraft.entity.DroppedBookEntity>>
+            DROPPED_BOOK = ENTITIES.register("dropped_book", () -> net.minecraft.world.entity.EntityType.Builder
+                    .<net.dnorberg.rivencraft.entity.DroppedBookEntity>of(
+                            net.dnorberg.rivencraft.entity.DroppedBookEntity::new, net.minecraft.world.entity.MobCategory.MISC)
+                    .sized(0.65F, 0.4F).clientTrackingRange(10).updateInterval(20)
+                    .build(net.minecraft.resources.ResourceKey.create(Registries.ENTITY_TYPE,
+                            Identifier.fromNamespaceAndPath(MOD_ID, "dropped_book"))));
+    private static final DeferredRegister<SoundEvent> SOUNDS =
+            DeferredRegister.create(Registries.SOUND_EVENT, MOD_ID);
+    public static final Supplier<SoundEvent> LINK = sound("linking.link");
+    public static final Supplier<SoundEvent> LINK_DISARM = sound("linking.link-disarm");
+    public static final Supplier<SoundEvent> LINK_INTRA = sound("linking.link-intra");
+    public static final Supplier<SoundEvent> LINK_FISSURE = sound("linking.link-fissure");
+    public static final Supplier<SoundEvent> LINK_PORTAL = sound("linking.link-portal");
+    public static final Supplier<SoundEvent> METEOR_ROAR = sound("entity.meteor.roar");
+
+    private static Supplier<SoundEvent> sound(String name) {
+        return SOUNDS.register(name, () -> SoundEvent.createVariableRangeEvent(
+                Identifier.fromNamespaceAndPath(MOD_ID, name)));
+    }
+    private static final DeferredRegister<BlockEntityType<?>> BLOCK_ENTITY_TYPES =
+            DeferredRegister.create(Registries.BLOCK_ENTITY_TYPE, MOD_ID);
+    private static final DeferredRegister<MenuType<?>> MENUS =
+            DeferredRegister.create(Registries.MENU, MOD_ID);
+    private static final DeferredRegister<RecipeSerializer<?>> RECIPE_SERIALIZERS =
+            DeferredRegister.create(Registries.RECIPE_SERIALIZER, MOD_ID);
+    private static final DeferredRegister.DataComponents COMPONENTS =
+            DeferredRegister.createDataComponents(Registries.DATA_COMPONENT_TYPE, MOD_ID);
+
+    public static final Supplier<DataComponentType<Identifier>> AGE_BOOK_ID = COMPONENTS.registerComponentType(
+            "age_book_id", builder -> builder.persistent(Identifier.CODEC)
+                    .networkSynchronized(Identifier.STREAM_CODEC));
+    public static final Supplier<DataComponentType<net.dnorberg.rivencraft.writing.NotebookContents>> NOTEBOOK_CONTENTS =
+            COMPONENTS.registerComponentType("notebook_contents", builder -> builder
+                    .persistent(net.dnorberg.rivencraft.writing.NotebookContents.CODEC)
+                    .networkSynchronized(net.dnorberg.rivencraft.writing.NotebookContents.STREAM_CODEC));
+    public static final Supplier<DataComponentType<String>> LINK_DESTINATION_NAME = COMPONENTS.registerComponentType(
+            "link_destination_name", builder -> builder.persistent(Codec.STRING).networkSynchronized(ByteBufCodecs.STRING_UTF8));
+    public static final Supplier<DataComponentType<LinkBookTarget>> LINK_BOOK_TARGET = COMPONENTS.registerComponentType(
+            "link_book_target", builder -> builder.persistent(LinkBookTarget.CODEC)
+                    .networkSynchronized(LinkBookTarget.STREAM_CODEC));
+    /** A present component distinguishes Link Panels from unwritten base Pages. */
+    public static final Supplier<DataComponentType<Boolean>> LINK_PANEL_PAGE = COMPONENTS.registerComponentType(
+            "link_panel_page", builder -> builder.persistent(Codec.BOOL)
+                    .networkSynchronized(ByteBufCodecs.BOOL));
+    public static final Supplier<DataComponentType<Identifier>> SYMBOL_PAGE_ID = COMPONENTS.registerComponentType(
+            "symbol_page_id", builder -> builder.persistent(Identifier.CODEC)
+                    .networkSynchronized(Identifier.STREAM_CODEC));
+    /** Ordered authored page IDs remain on the finished book for later port slices. */
+    public static final Supplier<DataComponentType<String>> BOOK_AUTHOR = COMPONENTS.registerComponentType(
+            "book_author", builder -> builder.persistent(Codec.STRING).networkSynchronized(ByteBufCodecs.STRING_UTF8));
+    public static final Supplier<DataComponentType<java.util.List<Identifier>>> BOOK_SYMBOLS = COMPONENTS.registerComponentType(
+            "book_symbols", builder -> builder.persistent(Identifier.CODEC.listOf())
+                    .networkSynchronized(ByteBufCodecs.<io.netty.buffer.ByteBuf, Identifier>list(252)
+                            .apply(Identifier.STREAM_CODEC)));
+    /** Set only on temporary GUI stacks; NeoForge 26.3 requires a registered codec. */
+    public static final Supplier<DataComponentType<Boolean>> PAGE_GLYPH_ONLY = COMPONENTS.registerComponentType(
+            "page_glyph_only", builder -> builder.persistent(Codec.BOOL)
+                    .networkSynchronized(ByteBufCodecs.BOOL));
+    public static final Supplier<DataComponentType<Integer>> INK_REMAINING = COMPONENTS.registerComponentType(
+            "ink_remaining", builder -> builder.persistent(Codec.INT)
+                    .networkSynchronized(ByteBufCodecs.VAR_INT));
+    public static final Supplier<DataComponentType<LinkProperties>> LINK_PROPERTIES = COMPONENTS.registerComponentType(
+            "link_properties", builder -> builder.persistent(LinkProperties.CODEC)
+                    .networkSynchronized(LinkProperties.STREAM_CODEC));
+
+    public static final DeferredBlock<Block> CRYSTAL_BLOCK = BLOCKS.registerBlock("crystal_block",
+            Block::new, () -> BlockBehaviour.Properties.ofFullCopy(Blocks.AMETHYST_BLOCK));
+    public static final DeferredBlock<net.dnorberg.rivencraft.block.CloudPlatformBlock> CLOUD_PLATFORM =
+            BLOCKS.registerBlock("cloud_platform", net.dnorberg.rivencraft.block.CloudPlatformBlock::new,
+                    () -> BlockBehaviour.Properties.ofFullCopy(Blocks.AMETHYST_BLOCK)
+                            .mapColor(MapColor.COLOR_BLUE).strength(0.3F).noLootTable());
+    public static final DeferredBlock<net.dnorberg.rivencraft.block.BookReceptacleBlock> BOOK_RECEPTACLE =
+            BLOCKS.registerBlock("book_receptacle", net.dnorberg.rivencraft.block.BookReceptacleBlock::new,
+                    () -> BlockBehaviour.Properties.ofFullCopy(Blocks.AMETHYST_BLOCK).noOcclusion().mapColor(MapColor.COLOR_BLUE));
+    public static final DeferredItem<BlockItem> BOOK_RECEPTACLE_ITEM = ITEMS.registerSimpleBlockItem(BOOK_RECEPTACLE);
+    public static final DeferredBlock<net.dnorberg.rivencraft.block.CrystalPortalBlock> CRYSTAL_PORTAL =
+            BLOCKS.registerBlock("crystal_portal", net.dnorberg.rivencraft.block.CrystalPortalBlock::new,
+                    () -> BlockBehaviour.Properties.ofFullCopy(Blocks.NETHER_PORTAL)
+                            .noCollision().noOcclusion().lightLevel(state -> 11).noLootTable());
+    public static final Supplier<BlockEntityType<net.dnorberg.rivencraft.block.entity.BookReceptacleBlockEntity>> BOOK_RECEPTACLE_BLOCK_ENTITY =
+            BLOCK_ENTITY_TYPES.register("book_receptacle", () -> new BlockEntityType<>(
+                    net.dnorberg.rivencraft.block.entity.BookReceptacleBlockEntity::new, BOOK_RECEPTACLE.get()));
+    public static final Supplier<BlockEntityType<net.dnorberg.rivencraft.block.entity.CrystalPortalBlockEntity>> CRYSTAL_PORTAL_BLOCK_ENTITY =
+            BLOCK_ENTITY_TYPES.register("crystal_portal", () -> new BlockEntityType<>(
+                    net.dnorberg.rivencraft.block.entity.CrystalPortalBlockEntity::new, CRYSTAL_PORTAL.get()));
+    public static final DeferredBlock<net.dnorberg.rivencraft.block.DecayBlock> DECAY =
+            BLOCKS.registerBlock("decay", net.dnorberg.rivencraft.block.DecayBlock::new,
+                    () -> BlockBehaviour.Properties.ofFullCopy(Blocks.STONE).strength(5.0F, 10.0F).noLootTable());
+    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 Supplier<BlockEntityType<StarFissureBlockEntity>>
+            STAR_FISSURE_BLOCK_ENTITY = BLOCK_ENTITY_TYPES.register("star_fissure", () -> new BlockEntityType<>(
+                    StarFissureBlockEntity::new, STAR_FISSURE.get()));
+    public static final DeferredBlock<net.dnorberg.rivencraft.block.BookStandBlock> BOOK_STAND =
+            BLOCKS.registerBlock("book_stand", net.dnorberg.rivencraft.block.BookStandBlock::new,
+                    () -> BlockBehaviour.Properties.ofFullCopy(Blocks.LECTERN));
+    public static final Supplier<BlockEntityType<net.dnorberg.rivencraft.block.entity.BookStandBlockEntity>> BOOK_STAND_BLOCK_ENTITY =
+            BLOCK_ENTITY_TYPES.register("book_stand", () -> new BlockEntityType<>(
+                    net.dnorberg.rivencraft.block.entity.BookStandBlockEntity::new, BOOK_STAND.get()));
+    public static final DeferredBlock<PortBookBinderBlock> BOOK_BINDER = BLOCKS.registerBlock(
+            "book_binder", PortBookBinderBlock::new,
+            () -> BlockBehaviour.Properties.ofFullCopy(Blocks.CRAFTING_TABLE).noOcclusion());
+    public static final DeferredItem<BlockItem> BOOK_BINDER_ITEM = ITEMS.registerSimpleBlockItem(BOOK_BINDER);
+    public static final DeferredBlock<net.dnorberg.rivencraft.block.LinkModifierBlock> LINK_MODIFIER = BLOCKS.registerBlock(
+            "link_modifier", net.dnorberg.rivencraft.block.LinkModifierBlock::new,
+            () -> BlockBehaviour.Properties.ofFullCopy(Blocks.STONE).noOcclusion());
+    public static final DeferredItem<BlockItem> LINK_MODIFIER_ITEM = ITEMS.registerSimpleBlockItem(LINK_MODIFIER);
+    public static final Supplier<BlockEntityType<net.dnorberg.rivencraft.block.entity.LinkModifierBlockEntity>> LINK_MODIFIER_BLOCK_ENTITY =
+            BLOCK_ENTITY_TYPES.register("link_modifier", () -> new BlockEntityType<>(
+                    net.dnorberg.rivencraft.block.entity.LinkModifierBlockEntity::new, LINK_MODIFIER.get()));
+    public static final Supplier<MenuType<net.dnorberg.rivencraft.menu.LinkModifierMenu>> LINK_MODIFIER_MENU =
+            MENUS.register("link_modifier", () -> IMenuTypeExtension.create(net.dnorberg.rivencraft.menu.LinkModifierMenu::new));
+    public static final DeferredBlock<InkMixerBlock> INK_MIXER = BLOCKS.registerBlock(
+            "ink_mixer", InkMixerBlock::new,
+            () -> BlockBehaviour.Properties.ofFullCopy(Blocks.CRAFTING_TABLE).noOcclusion());
+    public static final DeferredItem<BlockItem> INK_MIXER_ITEM = ITEMS.registerSimpleBlockItem(INK_MIXER);
+    public static final Supplier<BlockEntityType<PortBookBinderBlockEntity>> BOOK_BINDER_BLOCK_ENTITY =
+            BLOCK_ENTITY_TYPES.register("book_binder", () ->
+                    new BlockEntityType<>(PortBookBinderBlockEntity::new, BOOK_BINDER.get()));
+    public static final Supplier<MenuType<PortBookBinderMenu>> BOOK_BINDER_MENU =
+            MENUS.register("book_binder", () -> IMenuTypeExtension.create(PortBookBinderMenu::new));
+    public static final Supplier<BlockEntityType<InkMixerBlockEntity>> INK_MIXER_BLOCK_ENTITY =
+            BLOCK_ENTITY_TYPES.register("ink_mixer", () ->
+                    new BlockEntityType<>(InkMixerBlockEntity::new, INK_MIXER.get()));
+    public static final Supplier<MenuType<InkMixerMenu>> INK_MIXER_MENU =
+            MENUS.register("ink_mixer", () -> IMenuTypeExtension.create(InkMixerMenu::new));
+    public static final DeferredBlock<net.dnorberg.rivencraft.block.WritingDeskBlock> WRITING_DESK =
+            BLOCKS.registerBlock("writing_desk", net.dnorberg.rivencraft.block.WritingDeskBlock::new,
+                    () -> BlockBehaviour.Properties.ofFullCopy(Blocks.CRAFTING_TABLE).noOcclusion());
+    public static final DeferredItem<BlockItem> WRITING_DESK_ITEM = ITEMS.registerSimpleBlockItem(WRITING_DESK);
+    public static final Supplier<BlockEntityType<net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity>> WRITING_DESK_BLOCK_ENTITY =
+            BLOCK_ENTITY_TYPES.register("writing_desk", () -> new BlockEntityType<>(
+                    net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity::new, WRITING_DESK.get()));
+    public static final Supplier<MenuType<net.dnorberg.rivencraft.menu.WritingDeskMenu>> WRITING_DESK_MENU =
+            MENUS.register("writing_desk", () -> IMenuTypeExtension.create(net.dnorberg.rivencraft.menu.WritingDeskMenu::new));
+    public static final Supplier<MenuType<net.dnorberg.rivencraft.menu.NotebookMenu>> NOTEBOOK_MENU =
+            MENUS.register("notebook", () -> IMenuTypeExtension.create(net.dnorberg.rivencraft.menu.NotebookMenu::new));
+    public static final DeferredItem<net.dnorberg.rivencraft.item.NotebookItem> NOTEBOOK =
+            ITEMS.registerItem("notebook", net.dnorberg.rivencraft.item.NotebookItem::new, properties -> properties.stacksTo(1));
+    public static final DeferredItem<net.dnorberg.rivencraft.item.CollationFolderItem> COLLATION_FOLDER =
+            ITEMS.registerItem("collation_folder", net.dnorberg.rivencraft.item.CollationFolderItem::new, properties -> properties.stacksTo(1));
+    public static final DeferredItem<net.dnorberg.rivencraft.item.SymbolPortfolioItem> SYMBOL_PORTFOLIO =
+            ITEMS.registerItem("symbol_portfolio", net.dnorberg.rivencraft.item.SymbolPortfolioItem::new, properties -> properties.stacksTo(1));
+    public static final DeferredItem<net.dnorberg.rivencraft.item.SealedNotebookItem> SEALED_NOTEBOOK =
+            ITEMS.registerItem("sealed_notebook", net.dnorberg.rivencraft.item.SealedNotebookItem::new, properties -> properties.stacksTo(16));
+    public static final DeferredItem<BlockItem> CRYSTAL_BLOCK_ITEM = ITEMS.registerSimpleBlockItem(CRYSTAL_BLOCK);
+    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 DeferredItem<BlockItem> BUDDING_CRYSTAL_ITEM = ITEMS.registerSimpleBlockItem(BUDDING_CRYSTAL);
+    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 DeferredItem<BlockItem> SMALL_CRYSTAL_BUD_ITEM = ITEMS.registerSimpleBlockItem(SMALL_CRYSTAL_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 DeferredItem<BlockItem> MEDIUM_CRYSTAL_BUD_ITEM = ITEMS.registerSimpleBlockItem(MEDIUM_CRYSTAL_BUD);
+    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 DeferredItem<BlockItem> LARGE_CRYSTAL_BUD_ITEM = ITEMS.registerSimpleBlockItem(LARGE_CRYSTAL_BUD);
+    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 DeferredItem<BlockItem> CRYSTAL_CLUSTER_ITEM = ITEMS.registerSimpleBlockItem(CRYSTAL_CLUSTER);
+    public static final DeferredItem<Item> CRYSTAL_SHARD = ITEMS.registerSimpleItem("crystal_shard");
+    public static final DeferredItem<PageItem> PAGE = ITEMS.registerItem("page", PageItem::new);
+    public static final DeferredItem<InkVialItem> INK_VIAL = ITEMS.registerItem(
+            "ink_vial", InkVialItem::new, properties -> properties.stacksTo(16));
+    public static final DeferredItem<DescriptiveBookItem> DESCRIPTIVE_BOOK = ITEMS.registerItem(
+            "descriptive_book", DescriptiveBookItem::new, properties -> properties.stacksTo(1));
+    public static final DeferredItem<LinkingBookItem> LINKING_BOOK = ITEMS.registerItem(
+            "linking_book", LinkingBookItem::new, properties -> properties.stacksTo(1));
+    public static final Supplier<RecipeSerializer<LinkingBookRecipe>> LINKING_BOOK_RECIPE =
+            RECIPE_SERIALIZERS.register("linking_book", () -> LinkingBookRecipe.SERIALIZER);
+
+    public Rivencraft(IEventBus modEventBus, net.neoforged.fml.ModContainer container) {
+        container.registerConfig(net.neoforged.fml.config.ModConfig.Type.LOCAL, PortConfig.SPEC);
+        BLOCKS.register(modEventBus);
+        SOUNDS.register(modEventBus);
+        ITEMS.register(modEventBus);
+        ENTITIES.register(modEventBus);
+        BLOCK_ENTITY_TYPES.register(modEventBus);
+        MENUS.register(modEventBus);
+        COMPONENTS.register(modEventBus);
+        RECIPE_SERIALIZERS.register(modEventBus);
+        ModCreativeTabs.register(modEventBus);
+        PortBiomeSources.register(modEventBus);
+        PortChunkGenerators.register(modEventBus);
+        NeoForge.EVENT_BUS.addListener(RuntimeAgeBackend::onLevelLoad);
+        NeoForge.EVENT_BUS.addListener(net.dnorberg.rivencraft.age.PortAgeWeather::onLevelTickPre);
+        NeoForge.EVENT_BUS.addListener(net.dnorberg.rivencraft.age.PortAcceleratedTicks::onLevelTickPost);
+        NeoForge.EVENT_BUS.addListener(PortAgeCommands::register);
+        NeoForge.EVENT_BUS.addListener(net.dnorberg.rivencraft.event.BookStandConversionHandler::onRightClickBlock);
+        NeoForge.EVENT_BUS.addListener(AgeCatalogSync::onLogin);
+        NeoForge.EVENT_BUS.addListener(AgeCatalogSync::onLogout);
+        NeoForge.EVENT_BUS.addListener(AgeCatalogSync::onServerStopped);
+        modEventBus.addListener(AgeCatalogSync::registerPayloads);
+        modEventBus.addListener(PortBookNetworking::registerPayloads);
+        net.dnorberg.rivencraft.age.PortStatusEffectProviders.register();
+        net.dnorberg.rivencraft.age.PortDecayProviders.register();
+        net.dnorberg.rivencraft.age.PortHazardProviders.register();
+        net.dnorberg.rivencraft.age.PortMeteorProvider.register();
+        net.dnorberg.rivencraft.age.PortEnvironmentalProviders.register();
+        LOGGER.info("Initializing Rivencraft 26.3 port slice (not release-ready)");
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/advancement/ProgressionAdvancements.java

@@ -0,0 +1,28 @@
+package net.dnorberg.rivencraft.advancement;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.age.RuntimeAgeBackend;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerPlayer;
+
+/** Awards action-only progression after the server has committed the action. */
+public final class ProgressionAdvancements {
+    public static final String OPEN_PORTAL = "open_portal";
+    public static final String LINK_PANEL = "link_panel";
+    public static final String COPY_PAGE = "copy_page";
+    public static final String BIND_AGE = "bind_age";
+    public static final String ENTER_AGE = "enter_age";
+
+    private ProgressionAdvancements() {}
+
+    public static void award(ServerPlayer player, String path) {
+        var advancement = player.level().getServer().getAdvancements().get(
+                Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "progression/" + path));
+        if (advancement != null) player.getAdvancements().award(advancement, "completed");
+    }
+
+    public static void awardAgeTravel(ServerPlayer player) {
+        if (RuntimeAgeBackend.savedAges(player.level().getServer()).containsKey(player.level().dimension().identifier()))
+            award(player, ENTER_AGE);
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/AgeCatalogAckPayload.java

@@ -0,0 +1,22 @@
+package net.dnorberg.rivencraft.age;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.Identifier;
+
+/** Acknowledges the exact catalog version applied on the client main thread. */
+public record AgeCatalogAckPayload(int version) implements CustomPacketPayload {
+    public static final Type<AgeCatalogAckPayload> TYPE = new Type<>(
+            Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "age_catalog_ack"));
+    public static final StreamCodec<RegistryFriendlyByteBuf, AgeCatalogAckPayload> STREAM_CODEC = StreamCodec.composite(
+            ByteBufCodecs.VAR_INT, AgeCatalogAckPayload::version, AgeCatalogAckPayload::new
+    );
+
+    @Override
+    public Type<AgeCatalogAckPayload> type() {
+        return TYPE;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/AgeCatalogPayload.java

@@ -0,0 +1,37 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.Identifier;
+
+/** Full server level catalog, sent on login and after a runtime Age is added. */
+public record AgeCatalogPayload(int version, List<Identifier> dimensions,
+                                Map<Identifier, PortAgeColors> colors,
+                                Map<Identifier, PortDayCycle> dayCycles) implements CustomPacketPayload {
+    public static final Type<AgeCatalogPayload> TYPE = new Type<>(
+            Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "age_catalog"));
+    public static final StreamCodec<RegistryFriendlyByteBuf, AgeCatalogPayload> STREAM_CODEC = StreamCodec.composite(
+            ByteBufCodecs.VAR_INT, AgeCatalogPayload::version,
+            Identifier.STREAM_CODEC.apply(ByteBufCodecs.list()), AgeCatalogPayload::dimensions,
+            ByteBufCodecs.map(HashMap::new, Identifier.STREAM_CODEC, PortAgeColors.STREAM_CODEC), AgeCatalogPayload::colors,
+            ByteBufCodecs.map(HashMap::new, Identifier.STREAM_CODEC, PortDayCycle.STREAM_CODEC), AgeCatalogPayload::dayCycles,
+            AgeCatalogPayload::new
+    );
+
+    public AgeCatalogPayload {
+        dimensions = List.copyOf(dimensions);
+        colors = Map.copyOf(colors);
+        dayCycles = Map.copyOf(dayCycles);
+    }
+
+    @Override
+    public Type<AgeCatalogPayload> type() {
+        return TYPE;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/AgeCatalogSync.java

@@ -0,0 +1,103 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.neoforged.neoforge.event.entity.player.PlayerEvent;
+import net.neoforged.neoforge.event.server.ServerStoppedEvent;
+import net.neoforged.neoforge.network.PacketDistributor;
+import net.neoforged.neoforge.network.event.RegisterPayloadHandlersEvent;
+
+/** Refuses runtime-Age travel until the connected client confirms its catalog. */
+public final class AgeCatalogSync {
+    private static final Map<MinecraftServer, State> STATES = new IdentityHashMap<>();
+
+    private AgeCatalogSync() {
+    }
+
+    public static void registerPayloads(RegisterPayloadHandlersEvent event) {
+        var registrar = event.registrar("10");
+        registrar.playToClient(AgeCatalogPayload.TYPE, AgeCatalogPayload.STREAM_CODEC);
+        registrar.playToServer(AgeCatalogAckPayload.TYPE, AgeCatalogAckPayload.STREAM_CODEC,
+                (payload, context) -> {
+                    if (context.player() instanceof ServerPlayer player) acknowledge(player, payload.version());
+                });
+    }
+
+    public static void onLogin(PlayerEvent.PlayerLoggedInEvent event) {
+        if (event.getEntity() instanceof ServerPlayer player) {
+            try {
+                send(player);
+            } catch (RuntimeException exception) {
+                Rivencraft.LOGGER.error("Could not send initial Age catalog to {}; travel remains blocked",
+                        player.getName().getString(), exception);
+            }
+        }
+    }
+
+    public static void onLogout(PlayerEvent.PlayerLoggedOutEvent event) {
+        if (event.getEntity() instanceof ServerPlayer player) {
+            State state = STATES.get(player.level().getServer());
+            if (state != null) state.acknowledged.remove(player.getUUID());
+        }
+    }
+
+    public static void onServerStopped(ServerStoppedEvent event) {
+        STATES.remove(event.getServer());
+    }
+
+    public static void onCatalogChanged(MinecraftServer server) {
+        State state = state(server);
+        state.version++;
+        state.acknowledged.clear();
+        for (ServerPlayer player : server.getPlayerList().getPlayers()) {
+            try {
+                send(player);
+            } catch (RuntimeException exception) {
+                Rivencraft.LOGGER.error("Could not send Age catalog to {}; travel remains blocked",
+                        player.getName().getString(), exception);
+            }
+        }
+    }
+
+    public static boolean ready(ServerPlayer player, Identifier target) {
+        MinecraftServer server = player.level().getServer();
+        State state = state(server);
+        return state.version == state.acknowledged.getOrDefault(player.getUUID(), -1)
+                && server.levelKeys().stream().anyMatch(key -> key.identifier().equals(target));
+    }
+
+    private static void send(ServerPlayer player) {
+        MinecraftServer server = player.level().getServer();
+        State state = state(server);
+        state.acknowledged.remove(player.getUUID());
+        var dimensions = server.levelKeys().stream().map(key -> key.identifier()).sorted().toList();
+        PacketDistributor.sendToPlayer(player, new AgeCatalogPayload(state.version, dimensions,
+                RuntimeAgeBackend.savedColors(server), RuntimeAgeBackend.savedDayCycles(server)));
+    }
+
+    private static void acknowledge(ServerPlayer player, int version) {
+        State state = state(player.level().getServer());
+        if (version != state.version) {
+            Rivencraft.LOGGER.warn("Ignoring stale Age catalog acknowledgement {} from {} (current {})",
+                    version, player.getName().getString(), state.version);
+            return;
+        }
+        state.acknowledged.put(player.getUUID(), version);
+        Rivencraft.LOGGER.info("Age catalog {} acknowledged by {}", version, player.getName().getString());
+    }
+
+    private static State state(MinecraftServer server) {
+        return STATES.computeIfAbsent(server, ignored -> new State());
+    }
+
+    private static final class State {
+        private int version = 1;
+        private final Map<UUID, Integer> acknowledged = new HashMap<>();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/AgeLevelIndex.java

@@ -0,0 +1,229 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+/** Server-owned seed index for the first-party 26.3 runtime-level prototype. */
+final class AgeLevelIndex extends SavedData {
+    private static final Codec<AgeLevelIndex> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            Codec.unboundedMap(Identifier.CODEC, Codec.LONG).fieldOf("ages").forGetter(index -> index.ages),
+            Identifier.CODEC.listOf().optionalFieldOf("retired", List.of())
+                    .forGetter(index -> List.copyOf(index.retired)),
+            Codec.unboundedMap(Identifier.CODEC, Identifier.CODEC).optionalFieldOf("biome_overrides", Map.of())
+                    .forGetter(index -> index.biomeOverrides),
+            Codec.unboundedMap(Identifier.CODEC, PortBiomePlan.CODEC).optionalFieldOf("biome_plans", Map.of())
+                    .forGetter(index -> index.biomePlans),
+            Codec.unboundedMap(Identifier.CODEC,
+                    Codec.STRING.xmap(PortAgeTerrain::valueOf, PortAgeTerrain::name))
+                    .optionalFieldOf("terrain", Map.of()).forGetter(index -> index.terrain),
+            Codec.unboundedMap(Identifier.CODEC, PortRockPlan.CODEC).optionalFieldOf("rocks", Map.of())
+                    .forGetter(index -> index.rocks),
+            Codec.unboundedMap(Identifier.CODEC, PortVegetationPlan.CODEC)
+                    .optionalFieldOf("vegetation", Map.of()).forGetter(index -> index.vegetation),
+            Codec.unboundedMap(Identifier.CODEC, Codec.intRange(1, 32))
+                    .optionalFieldOf("dungeons", Map.of()).forGetter(index -> index.dungeons),
+            Codec.unboundedMap(Identifier.CODEC, PortLakePlan.CODEC)
+                    .optionalFieldOf("lakes", Map.of()).forGetter(index -> index.lakes),
+            Codec.unboundedMap(Identifier.CODEC, PortTerrainFeaturePlan.CODEC)
+                    .optionalFieldOf("terrain_features", Map.of()).forGetter(index -> index.terrainFeatures),
+            Codec.unboundedMap(Identifier.CODEC, PortLighting.CODEC)
+                    .optionalFieldOf("lighting", Map.of()).forGetter(index -> index.lighting),
+            Codec.unboundedMap(Identifier.CODEC, PortSkyStyle.CODEC)
+                    .optionalFieldOf("sky", Map.of()).forGetter(index -> index.sky),
+            Codec.unboundedMap(Identifier.CODEC, PortAgeColors.CODEC)
+                    .optionalFieldOf("colors", Map.of()).forGetter(index -> index.colors),
+            Codec.unboundedMap(Identifier.CODEC, PortDayCycle.CODEC)
+                    .optionalFieldOf("day_cycles", Map.of()).forGetter(index -> index.dayCycles),
+            Codec.unboundedMap(Identifier.CODEC, Codec.STRING)
+                    .optionalFieldOf("display_names", Map.of()).forGetter(index -> index.displayNames)
+    ).apply(instance, AgeLevelIndex::new));
+
+    static final SavedDataType<AgeLevelIndex> TYPE = new SavedDataType<>(
+            Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "runtime_ages"),
+            AgeLevelIndex::new,
+            CODEC
+    );
+
+    private final Map<Identifier, Long> ages;
+    private final Set<Identifier> retired;
+    private final Map<Identifier, Identifier> biomeOverrides;
+    private final Map<Identifier, PortBiomePlan> biomePlans;
+    private final Map<Identifier, PortAgeTerrain> terrain;
+    private final Map<Identifier, PortRockPlan> rocks;
+    private final Map<Identifier, PortVegetationPlan> vegetation;
+    private final Map<Identifier, Integer> dungeons;
+    private final Map<Identifier, PortLakePlan> lakes;
+    private final Map<Identifier, PortTerrainFeaturePlan> terrainFeatures;
+    private final Map<Identifier, PortLighting> lighting;
+    private final Map<Identifier, PortSkyStyle> sky;
+    private final Map<Identifier, PortAgeColors> colors;
+    private final Map<Identifier, PortDayCycle> dayCycles;
+    private final Map<Identifier, String> displayNames;
+
+    private AgeLevelIndex() {
+        this.ages = new LinkedHashMap<>();
+        this.retired = new LinkedHashSet<>();
+        this.biomeOverrides = new LinkedHashMap<>();
+        this.biomePlans = new LinkedHashMap<>();
+        this.terrain = new LinkedHashMap<>();
+        this.rocks = new LinkedHashMap<>();
+        this.vegetation = new LinkedHashMap<>();
+        this.dungeons = new LinkedHashMap<>();
+        this.lakes = new LinkedHashMap<>();
+        this.terrainFeatures = new LinkedHashMap<>();
+        this.lighting = new LinkedHashMap<>();
+        this.sky = new LinkedHashMap<>();
+        this.colors = new LinkedHashMap<>();
+        this.dayCycles = new LinkedHashMap<>();
+        this.displayNames = new LinkedHashMap<>();
+    }
+
+    private AgeLevelIndex(Map<Identifier, Long> ages, List<Identifier> retired,
+                          Map<Identifier, Identifier> biomeOverrides,
+                          Map<Identifier, PortBiomePlan> biomePlans,
+                          Map<Identifier, PortAgeTerrain> terrain,
+                          Map<Identifier, PortRockPlan> rocks,
+                          Map<Identifier, PortVegetationPlan> vegetation,
+                          Map<Identifier, Integer> dungeons,
+                          Map<Identifier, PortLakePlan> lakes,
+                          Map<Identifier, PortTerrainFeaturePlan> terrainFeatures,
+                          Map<Identifier, PortLighting> lighting,
+                          Map<Identifier, PortSkyStyle> sky, Map<Identifier, PortAgeColors> colors,
+                          Map<Identifier, PortDayCycle> dayCycles, Map<Identifier, String> displayNames) {
+        this.ages = new LinkedHashMap<>(ages);
+        this.retired = new LinkedHashSet<>(retired);
+        this.biomeOverrides = new LinkedHashMap<>(biomeOverrides);
+        this.biomePlans = new LinkedHashMap<>(biomePlans);
+        this.terrain = new LinkedHashMap<>(terrain);
+        this.rocks = new LinkedHashMap<>(rocks);
+        this.vegetation = new LinkedHashMap<>(vegetation);
+        this.dungeons = new LinkedHashMap<>(dungeons);
+        this.lakes = new LinkedHashMap<>(lakes);
+        this.terrainFeatures = new LinkedHashMap<>(terrainFeatures);
+        this.lighting = new LinkedHashMap<>(lighting);
+        this.sky = new LinkedHashMap<>(sky);
+        this.colors = new LinkedHashMap<>(colors);
+        this.dayCycles = new LinkedHashMap<>(dayCycles);
+        this.displayNames = new LinkedHashMap<>(displayNames);
+    }
+
+    String displayName(Identifier id) { return ages.containsKey(id) ? displayNames.get(id) : null; }
+
+    void setDisplayName(Identifier id, String name) {
+        if (!ages.containsKey(id)) throw new IllegalArgumentException("Age not indexed: " + id);
+        if (name == null || name.isBlank() || name.length() > 32) throw new IllegalArgumentException("Invalid Age display name");
+        displayNames.put(id, name.strip());
+        setDirty();
+    }
+
+    Map<Identifier, Long> entries() {
+        return Map.copyOf(ages);
+    }
+
+    boolean contains(Identifier id) {
+        return ages.containsKey(id) || retired.contains(id);
+    }
+
+    Long seed(Identifier id) {
+        return ages.get(id);
+    }
+
+    PortBiomePlan biomePlan(Identifier id) {
+        PortBiomePlan plan = biomePlans.get(id);
+        if (plan != null) return plan;
+        Identifier oldBiome = biomeOverrides.get(id);
+        return oldBiome == null ? null : new PortBiomePlan(PortBiomePlan.Distribution.SINGLE, List.of(oldBiome));
+    }
+
+    PortAgeTerrain terrain(Identifier id) {
+        return terrain.getOrDefault(id, PortAgeTerrain.STANDARD);
+    }
+
+    PortRockPlan rocks(Identifier id) { return rocks.get(id); }
+    PortVegetationPlan vegetation(Identifier id) { return vegetation.get(id); }
+    int dungeons(Identifier id) { return dungeons.getOrDefault(id, 0); }
+    PortLakePlan lakes(Identifier id) { return lakes.get(id); }
+    PortTerrainFeaturePlan terrainFeatures(Identifier id) { return terrainFeatures.get(id); }
+    PortLighting lighting(Identifier id) { return lighting.getOrDefault(id, PortLighting.NORMAL); }
+    PortSkyStyle sky(Identifier id) { return sky.getOrDefault(id, PortSkyStyle.OVERWORLD); }
+    PortAgeColors colors(Identifier id) { return colors.getOrDefault(id, PortAgeColors.NATIVE); }
+    Map<Identifier, PortAgeColors> colors() { return Map.copyOf(colors); }
+    PortDayCycle dayCycle(Identifier id) { return dayCycles.getOrDefault(id, PortDayCycle.NATIVE); }
+    Map<Identifier, PortDayCycle> dayCycles() { return Map.copyOf(dayCycles); }
+
+    void add(Identifier id, long seed, PortBiomePlan biomePlan, PortAgeTerrain ageTerrain,
+             PortRockPlan rockPlan, PortVegetationPlan vegetationPlan, int dungeonCount,
+             PortLakePlan lakePlan, PortTerrainFeaturePlan terrainFeaturePlan, PortLighting light, PortSkyStyle skyStyle,
+             PortAgeColors colorProfile, PortDayCycle dayCycle) {
+        if (contains(id)) {
+            throw new IllegalArgumentException("Age already exists: " + id);
+        }
+        ages.put(id, seed);
+        if (biomePlan != null) biomePlans.put(id, biomePlan);
+        if (ageTerrain != PortAgeTerrain.STANDARD) terrain.put(id, ageTerrain);
+        if (rockPlan != null) rocks.put(id, rockPlan);
+        if (vegetationPlan != null) vegetation.put(id, vegetationPlan);
+        if (dungeonCount > 0) dungeons.put(id, dungeonCount);
+        if (lakePlan != null) lakes.put(id, lakePlan);
+        if (terrainFeaturePlan != null) terrainFeatures.put(id, terrainFeaturePlan);
+        if (light != PortLighting.NORMAL) lighting.put(id, light);
+        if (skyStyle != PortSkyStyle.OVERWORLD) sky.put(id, skyStyle);
+        if (!colorProfile.equals(PortAgeColors.NATIVE)) colors.put(id, colorProfile);
+        if (!dayCycle.equals(PortDayCycle.NATIVE)) dayCycles.put(id, dayCycle);
+        setDirty();
+    }
+
+    void retire(Identifier id) {
+        if (ages.remove(id) == null) throw new IllegalArgumentException("Age not indexed: " + id);
+        biomeOverrides.remove(id);
+        biomePlans.remove(id);
+        terrain.remove(id);
+        rocks.remove(id);
+        vegetation.remove(id);
+        dungeons.remove(id);
+        lakes.remove(id);
+        terrainFeatures.remove(id);
+        lighting.remove(id);
+        sky.remove(id);
+        colors.remove(id);
+        dayCycles.remove(id);
+        retired.add(id);
+        setDirty();
+    }
+
+    void restoreAfterFailedRetirement(Identifier id, long seed, PortBiomePlan biomePlan,
+                                      PortAgeTerrain ageTerrain, PortRockPlan rockPlan,
+                                      PortVegetationPlan vegetationPlan, int dungeonCount,
+                                      PortLakePlan lakePlan, PortTerrainFeaturePlan terrainFeaturePlan, PortLighting light,
+                                      PortSkyStyle skyStyle, PortAgeColors colorProfile, PortDayCycle dayCycle) {
+        if (!retired.remove(id)) throw new IllegalStateException("Age is not retired: " + id);
+        ages.put(id, seed);
+        if (biomePlan != null) biomePlans.put(id, biomePlan);
+        if (ageTerrain != PortAgeTerrain.STANDARD) terrain.put(id, ageTerrain);
+        if (rockPlan != null) rocks.put(id, rockPlan);
+        if (vegetationPlan != null) vegetation.put(id, vegetationPlan);
+        if (dungeonCount > 0) dungeons.put(id, dungeonCount);
+        if (lakePlan != null) lakes.put(id, lakePlan);
+        if (terrainFeaturePlan != null) terrainFeatures.put(id, terrainFeaturePlan);
+        if (light != PortLighting.NORMAL) lighting.put(id, light);
+        if (skyStyle != PortSkyStyle.OVERWORLD) sky.put(id, skyStyle);
+        if (!colorProfile.equals(PortAgeColors.NATIVE)) colors.put(id, colorProfile);
+        if (!dayCycle.equals(PortDayCycle.NATIVE)) dayCycles.put(id, dayCycle);
+        setDirty();
+    }
+
+    void reseed(Identifier id, long seed) {
+        if (!ages.containsKey(id)) throw new IllegalArgumentException("Age not indexed: " + id);
+        ages.put(id, seed);
+        setDirty();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/InstabilityProviderCatalog.java

@@ -0,0 +1,74 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.ArrayList;
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.resources.Identifier;
+
+/** 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(Identifier 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(Identifier 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(Identifier.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);
+        }
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortAcceleratedTicks.java

@@ -0,0 +1,119 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import net.dnorberg.rivencraft.PortConfig;
+import net.minecraft.resources.Identifier;
+import net.neoforged.neoforge.event.tick.LevelTickEvent;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.SectionPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraft.util.RandomSource;
+
+/** Extra random block ticks from authored Accelerated pages, bounded to loaded player chunks. */
+public final class PortAcceleratedTicks {
+    public static final Identifier PAGE = Identifier.fromNamespaceAndPath("rivencraft", "environment/accelerated");
+
+    private PortAcceleratedTicks() {}
+
+    public static int pageCount(List<Identifier> pages) {
+        return (int) pages.stream().filter(PAGE::equals).count();
+    }
+
+    public static void configure(ServerLevel level, int pages) {
+        if (!(level instanceof PortAgeLevel)) throw new IllegalArgumentException("Not a Rivencraft Age");
+        level.getDataStorage().computeIfAbsent(PortAccelerationSettings.TYPE).setPages(pages);
+        level.getDataStorage().saveAndJoin();
+    }
+
+    public static int pages(ServerLevel level) {
+        return level.getDataStorage().computeIfAbsent(PortAccelerationSettings.TYPE).pages();
+    }
+
+    public static void onLevelTickPost(LevelTickEvent.Post event) {
+        if (event.getLevel() instanceof PortAgeLevel level) tick(level);
+    }
+
+    static void tick(ServerLevel level) {
+        int maximumAttempts = PortConfig.ACCELERATED_MAX_ATTEMPTS.get();
+        if (maximumAttempts == 0) return;
+        int pages = pages(level);
+        if (pages == 0) return;
+
+        List<ChunkPos> chunks = loadedPlayerChunks(level);
+        if (chunks.isEmpty()) return;
+        int maximumChunks = Math.min(chunks.size(), PortConfig.ACCELERATED_MAX_CHUNKS.get());
+        int first = Math.floorMod(level.getServer().getTickCount(), chunks.size());
+        List<TickSection> eligible = new ArrayList<>();
+        for (int offset = 0; offset < maximumChunks; offset++) {
+            ChunkPos pos = chunks.get((first + offset) % chunks.size());
+            LevelChunk chunk = level.getChunkSource().getChunkNow(pos.x(), pos.z());
+            if (chunk == null) continue;
+            LevelChunkSection[] sections = chunk.getSections();
+            for (int sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {
+                LevelChunkSection section = sections[sectionIndex];
+                if (!section.isRandomlyTickingBlocks()) continue;
+                int baseY = SectionPos.sectionToBlockCoord(chunk.getSectionYFromSectionIndex(sectionIndex));
+                eligible.add(new TickSection(pos, baseY, section));
+            }
+        }
+        if (eligible.isEmpty()) return;
+
+        // Legacy attempts three positions per random-ticking section per page. Divide
+        // the bounded total between sections before ticking any one of them, so a
+        // lower section cannot exhaust the entire budget ahead of surface crops.
+        int total = attemptBudget(pages, eligible.size(), maximumAttempts);
+        int perSection = total / eligible.size();
+        int remainder = total % eligible.size();
+        int firstSection = Math.floorMod(level.getServer().getTickCount(), eligible.size());
+        RandomSource random = level.getRandom();
+        for (int offset = 0; offset < eligible.size(); offset++) {
+            TickSection candidate = eligible.get((firstSection + offset) % eligible.size());
+            int samples = perSection + (offset < remainder ? 1 : 0);
+            for (int sample = 0; sample < samples; sample++) {
+                int x = random.nextInt(16);
+                int y = random.nextInt(16);
+                int z = random.nextInt(16);
+                BlockState state = candidate.section().getBlockState(x, y, z);
+                if (state.isRandomlyTicking()) {
+                    state.randomTick(level, new BlockPos(candidate.chunk().getMinBlockX() + x,
+                            candidate.baseY() + y, candidate.chunk().getMinBlockZ() + z), random);
+                }
+            }
+        }
+    }
+
+    static int attemptBudget(int pages, int sections, int maximumAttempts) {
+        if (pages < 0 || sections < 0 || maximumAttempts < 0)
+            throw new IllegalArgumentException("Negative accelerated tick budget input");
+        if (sections == 0) return 0;
+        long perSection = 3L * pages;
+        return perSection > maximumAttempts / (long) sections
+                ? maximumAttempts : (int) (perSection * sections);
+    }
+
+    private static List<ChunkPos> loadedPlayerChunks(ServerLevel level) {
+        Set<ChunkPos> chunks = new LinkedHashSet<>();
+        for (var player : level.players()) {
+            ChunkPos center = player.chunkPosition();
+            for (int x = -1; x <= 1; x++) {
+                for (int z = -1; z <= 1; z++) {
+                    int chunkX = center.x() + x;
+                    int chunkZ = center.z() + z;
+                    if (level.getChunkSource().hasChunk(chunkX, chunkZ)) {
+                        chunks.add(new ChunkPos(chunkX, chunkZ));
+                    }
+                }
+            }
+        }
+        return new ArrayList<>(chunks);
+    }
+
+    private record TickSection(ChunkPos chunk, int baseY, LevelChunkSection section) {}
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortAccelerationSettings.java

@@ -0,0 +1,24 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+/** Age-local authored page count, retained across unload, restart and reseeding. */
+final class PortAccelerationSettings extends SavedData {
+    private static final Codec<PortAccelerationSettings> CODEC = Codec.intRange(0, Integer.MAX_VALUE)
+            .fieldOf("pages").codec().xmap(PortAccelerationSettings::new, settings -> settings.pages);
+    static final SavedDataType<PortAccelerationSettings> TYPE = new SavedDataType<>(
+            Identifier.fromNamespaceAndPath("rivencraft", "acceleration"),
+            () -> new PortAccelerationSettings(0), CODEC);
+    private int pages;
+
+    private PortAccelerationSettings(int pages) { this.pages = pages; }
+    int pages() { return pages; }
+    void setPages(int pages) {
+        if (pages < 0) throw new IllegalArgumentException("Negative Accelerated page count");
+        this.pages = pages;
+        setDirty();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortAgeColors.java

@@ -0,0 +1,133 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.Level;
+import org.joml.Vector3f;
+import org.joml.Vector3fc;
+
+/** Frozen shared-color writing, adapted from 1.21.1 AgeSkyProfile. -1 means native. */
+public record PortAgeColors(int sky, int ambient, int celestial) {
+    public static final PortAgeColors NATIVE = new PortAgeColors(-1, -1);
+    public static final Codec<PortAgeColors> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            Codec.intRange(-1, 0xffffff).fieldOf("sky").forGetter(PortAgeColors::sky),
+            Codec.intRange(-1, 0xffffff).fieldOf("ambient").forGetter(PortAgeColors::ambient),
+            Codec.intRange(-1, 0xffffff).optionalFieldOf("celestial", -1).forGetter(PortAgeColors::celestial)
+    ).apply(instance, PortAgeColors::new));
+    public static final StreamCodec<RegistryFriendlyByteBuf, PortAgeColors> STREAM_CODEC = StreamCodec.composite(
+            ByteBufCodecs.INT, PortAgeColors::sky, ByteBufCodecs.INT, PortAgeColors::ambient,
+            ByteBufCodecs.INT, PortAgeColors::celestial, PortAgeColors::new);
+    public static final Identifier AMBIENT = Identifier.fromNamespaceAndPath("rivencraft", "lighting/ambient_color");
+    private static volatile Map<Identifier, PortAgeColors> clientColors = Map.of();
+
+    public PortAgeColors {
+        if (sky < -1 || sky > 0xffffff || ambient < -1 || ambient > 0xffffff
+                || celestial < -1 || celestial > 0xffffff)
+            throw new IllegalArgumentException("Invalid Age color");
+    }
+
+    public PortAgeColors(int sky, int ambient) { this(sky, ambient, -1); }
+
+    public static void updateClient(Map<Identifier, PortAgeColors> colors) { clientColors = Map.copyOf(colors); }
+
+    public static PortAgeColors forLevel(Level level) {
+        if (level instanceof PortAgeLevel age) return age.colors();
+        return level.isClientSide() ? clientColors.getOrDefault(level.dimension().identifier(), NATIVE) : NATIVE;
+    }
+
+    public static boolean isColor(Identifier page) {
+        return page.getNamespace().equals("rivencraft") && switch (page.getPath()) {
+            case "color/red", "color/green", "color/blue", "color/white", "color/black" -> true;
+            default -> false;
+        };
+    }
+
+    public static int number(Identifier page) {
+        if (!page.getNamespace().equals("rivencraft") || !page.getPath().startsWith("number/")) return -1;
+        try {
+            int value = Integer.parseInt(page.getPath().substring(7));
+            return value >= 0 && value <= 24 ? value : -1;
+        } catch (NumberFormatException exception) { return -1; }
+    }
+
+    public static boolean isModifier(Identifier page) { return isColor(page) || number(page) >= 0 || page.equals(AMBIENT); }
+
+    public static boolean validNumbers(List<Identifier> pages) {
+        for (int i = 0; i < pages.size(); i++)
+            if (number(pages.get(i)) >= 0 && (i + 1 == pages.size()
+                    || !isColor(pages.get(i + 1)) && !PortDayCycle.isPeriod(pages.get(i + 1))
+                    && !PortDayCycle.isPhase(pages.get(i + 1)) && !PortDayCycle.isAngle(pages.get(i + 1))
+                    && !PortDayCycle.isSize(pages.get(i + 1)))) return false;
+        return true;
+    }
+
+    public static PortAgeColors compile(List<Identifier> pages, long seed) {
+        // Numbers only attach to the immediately following target. Misplaced
+        // numbers are diagnosed by PortWritingRecovery, never moved to a later color.
+        int red = 0, green = 0, blue = 0, sky = -1, ambient = -1, celestial = -1;
+        boolean written = false;
+        for (int i = 0; i < pages.size(); i++) {
+            Identifier page = pages.get(i);
+            if (isColor(page)) {
+                int amount = i > 0 ? number(pages.get(i - 1)) : -1;
+                if (amount < 0) amount = new Random(seed ^ (0x9E3779B97F4A7C15L * (i + 1L))).nextInt(25);
+                amount *= 10;
+                written = true;
+                switch (page.getPath()) {
+                    case "color/red" -> red += amount;
+                    case "color/green" -> green += amount;
+                    case "color/blue" -> blue += amount;
+                    case "color/white" -> { red += amount; green += amount; blue += amount; }
+                    case "color/black" -> { red -= amount; green -= amount; blue -= amount; }
+                }
+            } else if (PortSkyStyle.forPage(page) != null || page.equals(AMBIENT)
+                    || PortDayCycle.isController(page)) {
+                if (PortDayCycle.isController(page)) celestial = -1;
+                if (written) {
+                    int rgb = clamp(red) << 16 | clamp(green) << 8 | clamp(blue);
+                    if (page.equals(AMBIENT)) ambient = rgb;
+                    else if (PortDayCycle.isController(page)) celestial = rgb;
+                    else sky = rgb;
+                }
+                red = green = blue = 0;
+                written = false;
+            }
+        }
+        if (written) sky = clamp(red) << 16 | clamp(green) << 8 | clamp(blue);
+        return new PortAgeColors(sky, ambient, celestial);
+    }
+
+    /** Only pageless random Ages receive a random sky tint, as in 1.21.1. */
+    public static PortAgeColors resolve(List<Identifier> pages, long seed) {
+        if (!pages.isEmpty()) return compile(pages, seed);
+        var random = new Random(seed ^ 0x534B5950524F464CL);
+        random.nextInt(5); // Root sky-style draw precedes the sky-color draw.
+        return new PortAgeColors(randomColor(random, true), -1);
+    }
+
+    /** Shared palette; retain .85's truncation for already-defined body defaults. */
+    static int randomColor(Random random, boolean rounded) {
+        int[] palette = {0xB74A50, 0xD9834B, 0xDBC574, 0x5AAB80, 0x6FA8DF, 0x9870B9, 0xD5DBE1, 0x252531};
+        int count = 1 + random.nextInt(3), red = 0, green = 0, blue = 0;
+        for (int i = 0; i < count; i++) {
+            int color = palette[random.nextInt(palette.length)];
+            red += color >> 16 & 255;
+            green += color >> 8 & 255;
+            blue += color & 255;
+        }
+        int offset = rounded ? count / 2 : 0;
+        return (red + offset) / count << 16 | (green + offset) / count << 8 | (blue + offset) / count;
+    }
+
+    private static int clamp(int value) { return Math.max(0, Math.min(255, value)); }
+    public static Vector3fc vector(int rgb) {
+        return new Vector3f((rgb >> 16 & 255) / 255f, (rgb >> 8 & 255) / 255f, (rgb & 255) / 255f);
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortAgeLevel.java

@@ -0,0 +1,63 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.dimension.LevelStem;
+import net.minecraft.world.level.saveddata.WeatherData;
+import net.minecraft.world.level.storage.DerivedLevelData;
+
+/** Runtime Age with independent native weather, rather than 26.3's shared server cycle. */
+final class PortAgeLevel extends ServerLevel {
+    private final WeatherData ageWeather;
+    private final PortWeatherSettings weatherSettings;
+    private final boolean cave;
+    private PortAgeColors colors = PortAgeColors.NATIVE;
+    private PortDayCycle dayCycle = PortDayCycle.NATIVE;
+
+    PortDayCycle dayCycle() { return dayCycle == null ? PortDayCycle.NATIVE : dayCycle; }
+    void configureDayCycle(PortDayCycle cycle) {
+        this.dayCycle = cycle;
+        environmentAttributes().invalidateTickCache();
+        updateSkyBrightness();
+    }
+
+    PortAgeColors colors() { return colors == null ? PortAgeColors.NATIVE : colors; }
+    void configureColors(PortAgeColors colors) {
+        this.colors = colors;
+        environmentAttributes().invalidateTickCache();
+    }
+
+    PortAgeLevel(MinecraftServer server, ResourceKey<Level> key, LevelStem stem,
+                 long biomeZoomSeed, PortAgeTerrain terrain) {
+        super(server, server.executor, server.storageSource,
+                new DerivedLevelData(server.getWorldData(), server.getWorldData().overworldData()),
+                key, stem, server.getWorldData().isDebugWorld(), biomeZoomSeed, List.of(), false);
+        ageWeather = getDataStorage().computeIfAbsent(WeatherData.TYPE);
+        weatherSettings = getDataStorage().computeIfAbsent(PortWeatherSettings.TYPE);
+        cave = terrain == PortAgeTerrain.CAVE;
+        PortAgeWeather.apply(this);
+        // The base constructor initializes visual levels from server weather.
+        // Replace them before publishing this Age or sending its join packets.
+        setRainLevel(ageWeather.isRaining() ? 1.0F : 0.0F);
+        setThunderLevel(ageWeather.isThundering() ? 1.0F : 0.0F);
+    }
+
+    @Override
+    public WeatherData getWeatherData() {
+        // The base constructor may query weather before our fields are initialized.
+        return ageWeather == null ? super.getWeatherData() : ageWeather;
+    }
+
+    PortWeatherMode weatherMode() { return cave ? PortWeatherMode.OFF : weatherSettings.mode(); }
+
+    void configureWeather(PortWeatherMode mode) {
+        weatherSettings.setMode(mode);
+        PortAgeWeather.apply(this);
+        setRainLevel(ageWeather.isRaining() ? 1.0F : 0.0F);
+        setThunderLevel(ageWeather.isThundering() ? 1.0F : 0.0F);
+        getDataStorage().saveAndJoin();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortAgeTerrain.java

@@ -0,0 +1,11 @@
+package net.dnorberg.rivencraft.age;
+
+/** Terrain variants currently backed by 26.3 vanilla noise settings. */
+public enum PortAgeTerrain {
+    STANDARD,
+    AMPLIFIED,
+    ISLAND,
+    CAVE,
+    FLAT,
+    VOID
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortAgeTravel.java

@@ -0,0 +1,184 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.Set;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/** Shared, server-authoritative landing for the 26.3 book and operator probe. */
+public final class PortAgeTravel {
+    private PortAgeTravel() {
+    }
+
+    public static String enter(ServerPlayer player, Identifier id) {
+        return enter(player, id, net.dnorberg.rivencraft.item.LinkProperties.NONE);
+    }
+    public static String enter(ServerPlayer player, Identifier id, net.dnorberg.rivencraft.item.LinkProperties properties) {
+        ServerLevel target = player.level().getServer().getLevel(ResourceKey.create(Registries.DIMENSION, id));
+        if (target == null) return "Age not loaded: " + id;
+        if (!AgeCatalogSync.ready(player, id)) {
+            return "Age catalog not acknowledged by client; remaining in source dimension";
+        }
+        BlockPos landing = resolveLanding(target, player, properties);
+        if (landing == null) return "No safe landing available; remaining in source dimension";
+        boolean moved = player.teleportTo(target, landing.getX() + 0.5, landing.getY(), landing.getZ() + 0.5,
+                Set.of(), player.getYRot(), player.getXRot(), true);
+        return moved ? null : "Teleportation failed; remaining in source dimension";
+    }
+
+    public static BlockPos resolveLanding(ServerLevel target) { return resolveLanding(target, true); }
+    public static BlockPos resolveLanding(ServerLevel target, net.minecraft.world.entity.Entity entity,
+                                          net.dnorberg.rivencraft.item.LinkProperties properties) {
+        BlockPos landing = resolveLanding(target, !properties.has(net.dnorberg.rivencraft.item.LinkProperties.DISABLE_PLATFORM));
+        if (landing == null || !properties.has(net.dnorberg.rivencraft.item.LinkProperties.RELATIVE_LINK)) return landing;
+        return findFootedDestination(target, net.dnorberg.rivencraft.item.PortLinkDestinations.relativeOrigin(
+                (ServerLevel) entity.level(), target, entity.blockPosition())).orElse(null);
+    }
+    public static BlockPos resolveLanding(ServerLevel target, boolean generatePlatform) {
+        boolean fissure = target.getChunkSource().getGenerator() instanceof PortFeatureChunkGenerator features
+                && features.terrainFeatures() != null && features.terrainFeatures().starFissures();
+        BlockPos landing = fissure ? PortStarFissureFeature.savedSpawn(target) : null;
+        if (landing != null) landing = isCaveTerrain(target)
+                ? findFootedDestination(target, landing).orElse(null)
+                : findSurfaceLanding(target, landing.getX(), landing.getZ());
+        if (landing == null) landing = findLanding(target, generatePlatform);
+        if (landing == null) return null;
+        if (fissure) PortStarFissureFeature.generateOnce(target, landing, isCaveTerrain(target));
+        if (target instanceof PortAgeLevel) PortInstabilityData.get(target.getServer()).recordSpawn(target, landing);
+        return landing;
+    }
+
+    static BlockPos findLanding(ServerLevel target) { return findLanding(target, true); }
+    static BlockPos findLanding(ServerLevel target, boolean generatePlatform) {
+        if (isCaveTerrain(target)) {
+            // The cave roof is not a valid arrival surface. Search down from
+            // Legacy's Y=64 start, then construct the normal safety platform
+            // at that height only when no footed opening can be found.
+            for (int radius = 0; radius <= 16; radius++) {
+                for (int x = -radius; x <= radius; x++) {
+                    for (int z = -radius; z <= radius; z++) {
+                        if (Math.max(Math.abs(x), Math.abs(z)) != radius) continue;
+                        for (int y = Math.min(64, target.getMaxY() - 2); y > target.getMinY(); y--) {
+                            BlockPos foot = new BlockPos(x, y, z);
+                            if (hasFooting(target, foot)) return foot;
+                        }
+                    }
+                }
+            }
+            return generatePlatform ? makePlatform(target, new BlockPos(0, 64, 0)) : null;
+        }
+        BlockPos surface = findSurfaceLanding(target, 0, 0);
+        if (surface != null) return surface;
+        // Only build above the actual highest obstruction, never in a pocket
+        // beneath it. Void Ages retain the usual platform floor at Y=63.
+        BlockPos obstruction = highestObstruction(target, 0, 0);
+        int y = obstruction == null ? 64 : Math.max(64, obstruction.getY() + 3);
+        return generatePlatform ? makePlatform(target, new BlockPos(0, y, 0)) : null;
+    }
+
+    static BlockPos findSurfaceLanding(ServerLevel target, int originX, int originZ) {
+        for (int radius = 0; radius <= 16; radius++) {
+            for (int x = -radius; x <= radius; x++) {
+                for (int z = -radius; z <= radius; z++) {
+                    if (Math.max(Math.abs(x), Math.abs(z)) != radius) continue;
+                    BlockPos floor = highestObstruction(target, originX + x, originZ + z);
+                    if (floor != null && hasFooting(target, floor.above())) return floor.above();
+                }
+            }
+        }
+        return null;
+    }
+
+    /** First obstructing surface seen from the sky; never continue through a roof or liquid. */
+    static BlockPos highestObstruction(ServerLevel level, int x, int z) {
+        var chunk = level.getChunk(x >> 4, z >> 4);
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos(x, level.getMaxY() - 1, z);
+        for (int y = level.getMaxY() - 1; y >= level.getMinY(); y--) {
+            pos.setY(y);
+            var state = chunk.getBlockState(pos);
+            if (!state.isAir() && (!state.getFluidState().isEmpty()
+                    || state.is(net.minecraft.tags.BlockTags.LEAVES)
+                    || !state.getCollisionShape(level, pos).isEmpty())) return pos.immutable();
+        }
+        return null;
+    }
+
+    private static boolean isCaveTerrain(ServerLevel target) {
+        var generator = target.getChunkSource().getGenerator();
+        if (generator instanceof PortFeatureChunkGenerator features) generator = features.base();
+        return generator instanceof net.minecraft.world.level.levelgen.NoiseBasedChunkGenerator noise
+                && noise.generatorSettings().value().noiseSettings().equals(target.registryAccess()
+                .lookupOrThrow(Registries.NOISE_SETTINGS)
+                .getOrThrow(net.minecraft.world.level.levelgen.NoiseGeneratorSettings.CAVES)
+                .value().noiseSettings());
+    }
+
+    private static BlockPos makePlatform(ServerLevel target, BlockPos foot) {
+        if (foot.getY() <= target.getMinY() || foot.getY() + 2 >= target.getMaxY()) return null;
+        // A carved pocket inside a flooded cave immediately refills. Refuse
+        // that landing instead of placing the player in submerged spawn space.
+        if (!target.getFluidState(foot).isEmpty() || !target.getFluidState(foot.above()).isEmpty()) return null;
+        for (Direction direction : Direction.Plane.HORIZONTAL) {
+            if (!target.getFluidState(foot.relative(direction)).isEmpty()
+                    || !target.getFluidState(foot.above().relative(direction)).isEmpty()) return null;
+        }
+        for (int x = -1; x <= 1; x++) {
+            for (int z = -1; z <= 1; z++) {
+                target.setBlock(foot.offset(x, -1, z), Rivencraft.CLOUD_PLATFORM.get().defaultBlockState(), 3);
+            }
+        }
+        target.setBlock(foot, Blocks.AIR.defaultBlockState(), 3);
+        target.setBlock(foot.above(), Blocks.AIR.defaultBlockState(), 3);
+        return foot;
+    }
+
+    private static boolean hasFooting(ServerLevel target, BlockPos foot) {
+        if (foot.getY() <= target.getMinY() || foot.getY() + 1 >= target.getMaxY()
+                || !target.getWorldBorder().isWithinBounds(foot)) return false;
+        BlockPos floor = foot.below();
+        var floorState = target.getBlockState(floor);
+        return (floorState.isFaceSturdy(target, floor, Direction.UP)
+                || floorState.is(net.minecraft.tags.BlockTags.LEAVES))
+                && floorState.getFluidState().isEmpty()
+                && target.getFluidState(foot).isEmpty()
+                && target.getFluidState(foot.above()).isEmpty()
+                && passable(target, foot) && passable(target, foot.above());
+    }
+
+    private static boolean passable(ServerLevel level, BlockPos pos) {
+        var state = level.getBlockState(pos);
+        return state.getCollisionShape(level, pos).isEmpty() || state.is(net.minecraft.tags.BlockTags.LEAVES);
+    }
+
+    /** Same local-then-surface safe-return search used by 1.21.1 fissures. */
+    public static java.util.Optional<BlockPos> findFootedDestination(ServerLevel level, BlockPos origin) {
+        var local = BlockPos.betweenClosedStream(origin.offset(-4, -2, -4), origin.offset(4, 2, 4))
+                .map(BlockPos::immutable).sorted(java.util.Comparator.comparingDouble(pos -> pos.distSqr(origin)))
+                .filter(pos -> level.isInWorldBounds(pos) && level.getWorldBorder().isWithinBounds(pos))
+                .filter(pos -> hasFooting(level, pos)).findFirst();
+        if (local.isPresent()) return local;
+        for (int radius = 1; radius <= 64; radius++) {
+            final int ring = radius;
+            var found = BlockPos.betweenClosedStream(origin.offset(-ring, 0, -ring), origin.offset(ring, 0, ring))
+                    .filter(pos -> Math.max(Math.abs(pos.getX() - origin.getX()), Math.abs(pos.getZ() - origin.getZ())) == ring)
+                    .map(BlockPos::immutable)
+                    .flatMap(pos -> {
+                        BlockPos surface = new BlockPos(pos.getX(),
+                                level.getHeight(Heightmap.Types.MOTION_BLOCKING, pos.getX(), pos.getZ()), pos.getZ());
+                        return java.util.stream.Stream.of(surface, surface.above(), surface.below(),
+                                surface.above(2), surface.below(2));
+                    })
+                    .filter(pos -> level.isInWorldBounds(pos) && level.getWorldBorder().isWithinBounds(pos))
+                    .filter(pos -> hasFooting(level, pos)).findFirst();
+            if (found.isPresent()) return found;
+        }
+        return java.util.Optional.empty();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortAgeVisits.java

@@ -0,0 +1,27 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+/** World-wide record of Ages for which an ON_CREATION Return Link was issued. */
+final class PortAgeVisits extends SavedData {
+    static final Codec<PortAgeVisits> CODEC = Identifier.CODEC.listOf().fieldOf("ages").codec()
+            .xmap(PortAgeVisits::new, visits -> visits.ages.stream().sorted().toList());
+    static final SavedDataType<PortAgeVisits> TYPE = new SavedDataType<>(
+            Identifier.fromNamespaceAndPath("rivencraft", "age_visits"),
+            () -> new PortAgeVisits(List.of()), CODEC);
+    private final Set<Identifier> ages;
+
+    PortAgeVisits(List<Identifier> ages) { this.ages = new HashSet<>(ages); }
+    boolean hasVisited(Identifier age) { return ages.contains(age); }
+    boolean markFirstVisit(Identifier age) {
+        if (!ages.add(age)) return false;
+        setDirty();
+        return true;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortAgeWeather.java

@@ -0,0 +1,52 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+import net.minecraft.world.level.saveddata.WeatherData;
+import net.neoforged.neoforge.event.tick.LevelTickEvent;
+
+/** 1.21.1 weather policies, applied before the independent native Age cycle advances. */
+public final class PortAgeWeather {
+    private static final Map<PortAgeLevel, Integer> STATES = new WeakHashMap<>();
+
+    private PortAgeWeather() {}
+
+    public static void onLevelTickPre(LevelTickEvent.Pre event) {
+        if (event.getLevel() instanceof PortAgeLevel level) apply(level);
+    }
+
+    static void apply(PortAgeLevel level) {
+        PortWeatherMode mode = level.weatherMode();
+        if (mode == PortWeatherMode.NORMAL) {
+            STATES.remove(level);
+            return;
+        }
+        WeatherData weather = level.getWeatherData();
+        if (mode == PortWeatherMode.FAST || mode == PortWeatherMode.SLOW) {
+            int state = (weather.isRaining() ? 1 : 0) | (weather.isThundering() ? 2 : 0);
+            Integer previous = STATES.put(level, state);
+            if (previous != null && previous == state) return;
+            // Keep persisted timers on reload; rescale only when a cycle changes.
+            if (previous == null && weather.getRainTime() > 0) return;
+            int scale = mode == PortWeatherMode.FAST ? 1 : 4;
+            int duration = 6000 * scale + level.getRandom().nextInt(
+                    (weather.isRaining() ? 6000 : 84000) * scale);
+            set(weather, duration, weather.isRaining(), weather.isThundering());
+        } else {
+            STATES.remove(level);
+            boolean rain = mode != PortWeatherMode.OFF;
+            boolean thunder = mode == PortWeatherMode.STORM;
+            if (weather.isRaining() != rain || weather.isThundering() != thunder
+                    || weather.getRainTime() < 200 || weather.getThunderTime() < 200
+                    || weather.getClearWeatherTime() != 0) set(weather, 6000, rain, thunder);
+        }
+    }
+
+    private static void set(WeatherData data, int duration, boolean rain, boolean thunder) {
+        data.setClearWeatherTime(0);
+        data.setRainTime(duration);
+        data.setThunderTime(duration);
+        data.setRaining(rain);
+        data.setThundering(thunder);
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortBinderCollectionProbe.java

@@ -0,0 +1,157 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.entity.PortBookBinderBlockEntity;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.menu.PortBookBinderMenu;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.minecraft.core.BlockPos;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.Container;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.Blocks;
+
+/** Disposable fixture for atomic collection imports and real Binder assembly. */
+final class PortBinderCollectionProbe {
+    private static final BlockPos BINDER = new BlockPos(0, 64, 0);
+    private static final BlockPos CHEST = new BlockPos(1, 64, 0);
+    private static final List<Identifier> EXPECTED = List.of(id("weather/off"), id("lighting/bright"),
+            id("terrain/flat"), id("biome/single"));
+    private PortBinderCollectionProbe() {}
+    private static Identifier id(String path) { return Identifier.fromNamespaceAndPath("rivencraft", path); }
+    private static ItemStack page(String path) { return PageItem.createSymbolPage(id(path)); }
+    private static ItemStack collection(boolean folder, List<ItemStack> pages) {
+        ItemStack result = new ItemStack(folder ? Rivencraft.COLLATION_FOLDER.get() : Rivencraft.NOTEBOOK.get());
+        result.set(Rivencraft.NOTEBOOK_CONTENTS.get(), new NotebookContents(pages));
+        return result;
+    }
+
+    static void create(ServerLevel level) {
+        PortAgeTravel.findLanding(level);
+        level.setBlock(BINDER, Rivencraft.BOOK_BINDER.get().defaultBlockState(), 3);
+        level.setBlock(CHEST, Blocks.CHEST.defaultBlockState(), 3);
+        var binder = (PortBookBinderBlockEntity) level.getBlockEntity(BINDER);
+        var chest = (Container) level.getBlockEntity(CHEST);
+        ItemStack folder = collection(true, List.of(page("weather/off"), ItemStack.EMPTY, page("lighting/bright")));
+        ItemStack before = folder.copy();
+        for (int i = 0; i < PortBookBinderBlockEntity.PAGE_COUNT; i++)
+            binder.setItem(PortBookBinderBlockEntity.FIRST_PAGE + i, page("terrain/flat"));
+        if (!binder.importCollection(folder, 0).isEmpty() || binder.nextPageIndex() != 252
+                || !ItemStack.isSameItemSameComponents(before, folder)
+                || binder.symbolPages().stream().anyMatch(symbol -> !symbol.equals(id("terrain/flat"))))
+            throw new IllegalStateException("Full Binder import was not atomic");
+        binder.clearSymbolPages();
+        binder.setItem(PortBookBinderBlockEntity.PANEL, PageItem.createLinkPanelPage());
+        if (!binder.importCollection(collection(true, List.of(page("weather/off"), PageItem.createLinkPanelPage())), 0).isEmpty()
+                || binder.hasSymbolPages() || binder.getItem(PortBookBinderBlockEntity.PANEL).isEmpty())
+            throw new IllegalStateException("Conflicting Link Panel import was not atomic");
+        binder.setItem(PortBookBinderBlockEntity.PANEL, ItemStack.EMPTY);
+        if (!binder.importCollection(folder, -1).isEmpty() || !binder.importCollection(folder, 1).isEmpty())
+            throw new IllegalStateException("Invalid collection insertion point accepted");
+        binder.insertPage(0, page("terrain/flat"));
+        var player = new PortProgressionPlayer(level,
+                new com.mojang.authlib.GameProfile(java.util.UUID.fromString("5225a1ed-5ead-44b5-a63c-c78e7dca86f5"), "RivenBinderProbe"));
+        player.setPos(0.5, 64, 2.5);
+        var menu = new PortBookBinderMenu(1, player.getInventory(), binder);
+        try {
+            menu.setCarried(folder);
+            if (!menu.clickMenuButton(player, PortBookBinderMenu.STRIP_CLICK_BASE + 1)
+                    || menu.getCarried().get(Rivencraft.NOTEBOOK_CONTENTS.get()).pageCount() != 0
+                    || !binder.symbolPages().equals(EXPECTED.subList(0, 3)))
+                throw new IllegalStateException("Cursor collection order/empty-cover regression");
+            chest.setItem(0, menu.getCarried().copy());
+            menu.setCarried(ItemStack.EMPTY);
+            player.getInventory().setItem(9, collection(false, List.of(page("biome/single"))));
+            menu.quickMoveStack(player, PortBookBinderBlockEntity.SIZE);
+            ItemStack emptied = player.getInventory().getItem(9);
+            if (!emptied.is(Rivencraft.NOTEBOOK.get())
+                    || emptied.get(Rivencraft.NOTEBOOK_CONTENTS.get()).pageCount() != 0
+                    || !binder.symbolPages().equals(EXPECTED))
+                throw new IllegalStateException("Shift collection import regression");
+            chest.setItem(1, emptied.copy());
+            binder.setItem(PortBookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+            binder.setItem(PortBookBinderBlockEntity.PANEL, PageItem.createLinkPanelPage());
+            menu.assemble(player, "Collection Fixture104");
+            ItemStack book = menu.getCarried();
+            if (!book.is(Rivencraft.DESCRIPTIVE_BOOK.get()) || !EXPECTED.equals(book.get(Rivencraft.BOOK_SYMBOLS.get()))
+                    || !book.has(Rivencraft.AGE_BOOK_ID.get()) || binder.hasSymbolPages()
+                    || !binder.getItem(PortBookBinderBlockEntity.COVER).isEmpty()
+                    || !binder.getItem(PortBookBinderBlockEntity.PANEL).isEmpty())
+                throw new IllegalStateException("Collection-backed Binder assembly regression");
+            if (!PortProgressionProbe.isComplete(player, "bind_age"))
+                throw new IllegalStateException("Missing bind_age award");
+            if (!player.getGameProfile().name().equals(book.get(Rivencraft.BOOK_AUTHOR.get())))
+                throw new IllegalStateException("Binder author was not server assigned");
+            var pages = net.dnorberg.rivencraft.writing.DescriptiveBookPages.from(book);
+            if (pages.lastPage() != EXPECTED.size() || pages.symbolAt(0).isPresent()
+                    || !pages.symbolAt(1).orElseThrow().equals(EXPECTED.getFirst())
+                    || !pages.symbolAt(EXPECTED.size()).orElseThrow().equals(EXPECTED.getLast())
+                    || pages.symbolAt(EXPECTED.size() + 1).isPresent()
+                    || pages.turn(0, -1) != 0 || pages.turn(pages.lastPage(), 1) != pages.lastPage())
+                throw new IllegalStateException("Authored book page indexing failed");
+            var old = net.dnorberg.rivencraft.writing.DescriptiveBookPages.from(new ItemStack(Rivencraft.DESCRIPTIVE_BOOK.get()));
+            if (old.lastPage() != 1 || !old.author().isEmpty() || old.symbolAt(1).isPresent())
+                throw new IllegalStateException("Older panel-only book fallback failed");
+            var repeated = new net.dnorberg.rivencraft.writing.DescriptiveBookPages(
+                    List.of(EXPECTED.getFirst(), EXPECTED.getFirst()), "Test");
+            if (repeated.lastPage() != 2 || !repeated.symbolAt(1).equals(repeated.symbolAt(2)))
+                throw new IllegalStateException("Repeated symbol display was collapsed");
+            var ageId = book.get(Rivencraft.AGE_BOOK_ID.get());
+            var server = level.getServer();
+            if (!RuntimeAgeBackend.savedAgeName(server, ageId).orElseThrow().equals("Collection Fixture104"))
+                throw new IllegalStateException("Created Age lost its display name");
+            var namedLevel = server.getLevel(net.minecraft.resources.ResourceKey.create(
+                    net.minecraft.core.registries.Registries.DIMENSION, ageId));
+            if (!net.dnorberg.rivencraft.item.LinkingBookItem.destinationName(namedLevel).equals("Collection Fixture104"))
+                throw new IllegalStateException("Link binding name lookup did not use Age title");
+            RuntimeAgeBackend.setAgeDisplayName(server, ageId, "Crystal Garden's Dawn");
+            var target = new net.dnorberg.rivencraft.item.LinkBookTarget(ageId, -0.5, 64, -1.25, 90, 0);
+            var link = new ItemStack(Rivencraft.LINKING_BOOK.get());
+            link.set(Rivencraft.LINK_BOOK_TARGET.get(), target);
+            link.set(Rivencraft.LINK_DESTINATION_NAME.get(), net.dnorberg.rivencraft.item.LinkingBookItem.destinationName(namedLevel));
+            if (!net.dnorberg.rivencraft.item.LinkingBookItem.destinationName(link, target).getString().equals("Crystal Garden's Dawn"))
+                throw new IllegalStateException("Link destination label ignored saved name");
+            var mode = net.dnorberg.rivencraft.PortConfig.RETURN_LINK_MODE.get();
+            player.getInventory().clearContent();
+            try {
+                net.dnorberg.rivencraft.PortConfig.RETURN_LINK_MODE.set(net.dnorberg.rivencraft.PortConfig.ReturnLinkMode.ALWAYS);
+                PortReturnLinks.afterSuccessfulTravel(player, ageId, target);
+                var returned = java.util.stream.IntStream.range(0, player.getInventory().getContainerSize())
+                        .mapToObj(i -> player.getInventory().getItem(i)).filter(i -> i.is(Rivencraft.LINKING_BOOK.get()))
+                        .findFirst().orElseThrow();
+                if (!"Crystal Garden's Dawn".equals(returned.get(Rivencraft.LINK_DESTINATION_NAME.get())))
+                    throw new IllegalStateException("Automatic Return Link lost departure name");
+                chest.setItem(4, returned.copy());
+            } finally { net.dnorberg.rivencraft.PortConfig.RETURN_LINK_MODE.set(mode); }
+            chest.setItem(3, link);
+            chest.setItem(2, book.copy());
+            menu.setCarried(ItemStack.EMPTY);
+        } finally { player.getInventory().clearContent(); }
+        verify(level);
+    }
+
+    static void verify(ServerLevel level) {
+        if (!(level.getBlockEntity(CHEST) instanceof Container chest)) throw new IllegalStateException("Fixture chest missing");
+        if (!chest.getItem(0).is(Rivencraft.COLLATION_FOLDER.get()) || !chest.getItem(1).is(Rivencraft.NOTEBOOK.get()))
+            throw new IllegalStateException("Empty collection covers were not preserved");
+        for (int i = 0; i < 2; i++) if (chest.getItem(i).get(Rivencraft.NOTEBOOK_CONTENTS.get()).pageCount() != 0)
+            throw new IllegalStateException("Imported pages remained in a collection");
+        if (!"RivenBinderProbe".equals(chest.getItem(2).get(Rivencraft.BOOK_AUTHOR.get())))
+            throw new IllegalStateException("Authored book lost its author");
+        var ageId = chest.getItem(2).get(Rivencraft.AGE_BOOK_ID.get());
+        if (!RuntimeAgeBackend.savedAgeName(level.getServer(), ageId).orElseThrow().equals("Crystal Garden's Dawn")
+                || !"Crystal Garden's Dawn".equals(chest.getItem(3).get(Rivencraft.LINK_DESTINATION_NAME.get()))
+                || !"Crystal Garden's Dawn".equals(chest.getItem(4).get(Rivencraft.LINK_DESTINATION_NAME.get())))
+            throw new IllegalStateException("Age/Linking/Return destination names did not survive persistence");
+        var old = new ItemStack(Rivencraft.LINKING_BOOK.get());
+        var overworld = new net.dnorberg.rivencraft.item.LinkBookTarget(net.minecraft.world.level.Level.OVERWORLD.identifier(), 0, 64, 0, 0, 0);
+        if (!net.dnorberg.rivencraft.item.LinkingBookItem.destinationName(old, overworld).getString()
+                .equals(net.minecraft.network.chat.Component.translatable("dimension.minecraft.overworld").getString()))
+            throw new IllegalStateException("Older book vanilla name fallback changed");
+        if (!EXPECTED.equals(chest.getItem(2).get(Rivencraft.BOOK_SYMBOLS.get())))
+            throw new IllegalStateException("Authored book page order was not preserved");
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortBiomeMaterialRules.java

@@ -0,0 +1,31 @@
+package net.dnorberg.rivencraft.age;
+
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.data.worldgen.material.EndMaterialRules;
+import net.minecraft.data.worldgen.material.NetherMaterialRules;
+import net.minecraft.world.level.biome.Biomes;
+import net.minecraft.world.level.levelgen.NoiseGeneratorSettings;
+import net.minecraft.world.level.levelgen.material.MaterialRules;
+
+/** Root AgeDimensionService.withBiomeMaterialRules adapted to 26.3's rule registry. */
+final class PortBiomeMaterialRules {
+    private PortBiomeMaterialRules() {}
+
+    static Holder<NoiseGeneratorSettings> apply(HolderLookup.Provider registries, NoiseGeneratorSettings base) {
+        var biomes = registries.lookupOrThrow(Registries.BIOME);
+        var rules = registries.lookupOrThrow(Registries.MATERIAL_RULE);
+        var materials = MaterialRules.sequence(
+                MaterialRules.ifTrue(MaterialRules.isBiome(biomes, Biomes.THE_END, Biomes.END_HIGHLANDS,
+                        Biomes.END_MIDLANDS, Biomes.SMALL_END_ISLANDS, Biomes.END_BARRENS),
+                        MaterialRules.getRule(rules, EndMaterialRules.END)),
+                MaterialRules.ifTrue(MaterialRules.isBiome(biomes, Biomes.NETHER_WASTES, Biomes.SOUL_SAND_VALLEY,
+                        Biomes.CRIMSON_FOREST, Biomes.WARPED_FOREST, Biomes.BASALT_DELTAS),
+                        MaterialRules.getRule(rules, NetherMaterialRules.NETHER)),
+                base.materialRule().value());
+        return Holder.direct(new NoiseGeneratorSettings(base.noiseSettings(), base.defaultBlock(), base.defaultFluid(),
+                base.noiseRouter(), Holder.direct(materials), base.spawnTarget(), base.seaLevel(), base.disableMobGeneration(),
+                base.aquifers(), base.useLegacyRandomSource(), base.debugFunctions()));
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortBiomePlan.java

@@ -0,0 +1,24 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.List;
+import net.minecraft.resources.Identifier;
+
+/** Frozen biome choice; Native may carry an explicit Cave pool. Repeats retain weight. */
+public record PortBiomePlan(Distribution distribution, List<Identifier> biomes) {
+    public enum Distribution { NATIVE, SINGLE, TILED, GRID, TINY, SMALL, MEDIUM, LARGE, HUGE }
+
+    public static final Codec<PortBiomePlan> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            Codec.STRING.xmap(Distribution::valueOf, Distribution::name).fieldOf("distribution")
+                    .forGetter(PortBiomePlan::distribution),
+            Identifier.CODEC.listOf().fieldOf("biomes").forGetter(PortBiomePlan::biomes)
+    ).apply(instance, PortBiomePlan::new));
+
+    public PortBiomePlan {
+        biomes = List.copyOf(biomes);
+        if (distribution == null || distribution == Distribution.SINGLE && biomes.size() != 1
+                || distribution != Distribution.NATIVE && distribution != Distribution.SINGLE && biomes.size() < 2)
+            throw new IllegalArgumentException("Invalid authored biome distribution");
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortBlockInstability.java

@@ -0,0 +1,314 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import net.dnorberg.rivencraft.Rivencraft;
+
+import net.dnorberg.rivencraft.writing.PortRegistryPages;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.status.ChunkStatus;
+import net.neoforged.neoforge.common.Tags;
+import net.neoforged.neoforge.event.level.ChunkEvent;
+import net.neoforged.neoforge.event.server.ServerStoppingEvent;
+import net.neoforged.neoforge.event.tick.ServerTickEvent;
+
+/** Legacy-style excess-block profiling with gradual spawn-area generation. */
+@net.neoforged.fml.common.EventBusSubscriber(modid = Rivencraft.MOD_ID)
+public final class PortBlockInstability {
+    // Legacy's watched blocks and factor-1 values; modern ore variants share their parent weight.
+    // Storage blocks are deliberate extensions, including the requested diamond-block case.
+    private static final Map<Identifier, Double> VANILLA_WEIGHTS = weights();
+    private static final Map<String, Double> COMMON_MINERAL_WEIGHTS = Map.ofEntries(
+            Map.entry("coal", 5.0), Map.entry("sulfur", 5.0), Map.entry("sulphur", 5.0),
+            Map.entry("salt", 5.0), Map.entry("tin", 60.0), Map.entry("lead", 60.0),
+            Map.entry("aluminum", 60.0), Map.entry("aluminium", 60.0),
+            Map.entry("zinc", 60.0), Map.entry("copper", 60.0),
+            Map.entry("iron", 60.0), Map.entry("nickel", 200.0),
+            Map.entry("osmium", 200.0), Map.entry("silver", 200.0),
+            Map.entry("emerald", 200.0), Map.entry("ruby", 200.0),
+            Map.entry("sapphire", 200.0), Map.entry("redstone", 250.0),
+            Map.entry("gold", 750.0), Map.entry("uranium", 750.0),
+            Map.entry("platinum", 750.0), Map.entry("diamond", 4000.0),
+            Map.entry("iridium", 4000.0), Map.entry("netherite", 8000.0));
+    private static final int MAX_PENDING = 2048;
+    private static final int SAMPLES_PER_TICK = 4;
+    private static final int GENERATION_INTERVAL_TICKS = 20;
+    private static final List<ChunkPos> SPAWN_OFFSETS = spawnOffsets();
+    private static final Map<MinecraftServer, ArrayDeque<Pending>> PENDING = new java.util.WeakHashMap<>();
+    private static final Map<MinecraftServer, Map<Identifier, Integer>> NEXT_SPAWN_SAMPLE =
+            new java.util.WeakHashMap<>();
+    private static final Map<MinecraftServer, Integer> NEXT_TARGET = new java.util.WeakHashMap<>();
+    private static final Map<MinecraftServer, Boolean> GENERATION_IN_FLIGHT =
+            new java.util.WeakHashMap<>();
+
+    private PortBlockInstability() {}
+
+    /** Track recognized materials from installed mods without requiring any mod-specific API. */
+    static boolean tracked(Identifier id) {
+        if (VANILLA_WEIGHTS.containsKey(id)) return true;
+        if (id.getNamespace().equals("minecraft") || id.getNamespace().equals("rivencraft")) return false;
+        if (!BuiltInRegistries.BLOCK.containsKey(id)) return false;
+        var block = BuiltInRegistries.BLOCK.getValue(id);
+        return eligibleMaterial(block) && (configuredOverride(id) != null || inferredModdedWeight(id, block) > 0);
+    }
+
+    static double weight(Identifier id) {
+        Double vanilla = VANILLA_WEIGHTS.get(id);
+        if (vanilla != null) return vanilla;
+        if (id.getNamespace().equals("minecraft") || id.getNamespace().equals("rivencraft")
+                || !BuiltInRegistries.BLOCK.containsKey(id)) return 0;
+        var block = BuiltInRegistries.BLOCK.getValue(id);
+        if (!eligibleMaterial(block)) return 0;
+        return moddedWeight(id, inferredModdedWeight(id, block),
+                PortInstabilityConfig.moddedMaterialOverrides());
+    }
+
+    private static boolean eligibleMaterial(net.minecraft.world.level.block.Block block) {
+        return PortRegistryPages.materialCategory(block) != null;
+    }
+
+    private static Double configuredOverride(Identifier id) {
+        return configuredOverride(id, PortInstabilityConfig.moddedMaterialOverrides());
+    }
+
+    private static Double configuredOverride(Identifier id, List<? extends String> overrides) {
+        for (String entry : overrides) {
+            int separator = entry.lastIndexOf('=');
+            if (separator > 0 && entry.substring(0, separator).equals(id.toString()))
+                return (double) Integer.parseInt(entry.substring(separator + 1));
+        }
+        return null;
+    }
+
+    static double moddedWeight(Identifier id, double inferred, List<? extends String> overrides) {
+        Double override = configuredOverride(id, overrides);
+        return override == null ? inferred : override;
+    }
+
+    private static double inferredModdedWeight(Identifier id, net.minecraft.world.level.block.Block block) {
+        if ("rivencraft:fluid".equals(PortRegistryPages.materialCategory(block))) return 1.25;
+        var state = block.defaultBlockState();
+        String path = id.getPath();
+        boolean ore = state.is(Tags.BlockItems.ORES.block()) || path.endsWith("_ore") || path.contains("_ore_");
+        boolean storage = state.is(Tags.BlockItems.STORAGE_BLOCKS.block())
+                || (path.endsWith("_block") || path.startsWith("block_of_"))
+                && namedMineralWeight(path) != null;
+        return inferredModdedWeight(id, ore, storage, false);
+    }
+
+    static double inferredModdedWeight(Identifier id, boolean ore, boolean storage, boolean fluid) {
+        if (fluid) return 1.25;
+        Double named = namedMineralWeight(id.getPath());
+        if (ore) return named == null ? 60.0 : named;
+        if (storage) return named == null ? 120.0 : named;
+        return 0;
+    }
+
+    private static Double namedMineralWeight(String path) {
+        for (String part : path.split("[/_]")) {
+            Double value = COMMON_MINERAL_WEIGHTS.get(part);
+            if (value != null) return value;
+        }
+        return null;
+    }
+
+    @net.neoforged.bus.api.SubscribeEvent
+    public static void onChunkLoad(ChunkEvent.Load event) {
+        if (!(event.getLevel() instanceof ServerLevel level)
+                || !(event.getChunk() instanceof LevelChunk chunk)) return;
+        boolean overworld = level.dimension() == net.minecraft.world.level.Level.OVERWORLD;
+        if (!overworld && !PortInstabilityRuntime.isAge(level)) return;
+        // Chunk-load callbacks can occur while chunk storage is updating. Defer saved-data
+        // access to a bounded server-tick lane to avoid reentering that storage path.
+        synchronized (PENDING) {
+            var queue = PENDING.computeIfAbsent(level.getServer(), ignored -> new ArrayDeque<>());
+            if (queue.size() < MAX_PENDING) queue.addLast(new Pending(level, chunk));
+        }
+    }
+
+    @net.neoforged.bus.api.SubscribeEvent
+    public static void onServerTickPost(ServerTickEvent.Post event) {
+        for (int index = 0; index < SAMPLES_PER_TICK; index++) {
+            Pending pending;
+            synchronized (PENDING) {
+                var queue = PENDING.get(event.getServer());
+                pending = queue == null ? null : queue.pollFirst();
+            }
+            if (pending == null) break;
+            var pos = pending.chunk().getPos();
+            if (pending.level().getServer().getLevel(pending.level().dimension()) == pending.level()
+                    && pending.level().getChunkSource().getChunkNow(pos.x(), pos.z()) == pending.chunk())
+                PortBlockProfileSavedData.get(pending.level()).sample(pending.chunk());
+        }
+        if (event.getServer().getTickCount() % GENERATION_INTERVAL_TICKS == 0) {
+            generateNextSpawnSample(event.getServer());
+        }
+    }
+
+    @net.neoforged.bus.api.SubscribeEvent
+    public static void onServerStopping(ServerStoppingEvent event) {
+        synchronized (PENDING) { PENDING.remove(event.getServer()); }
+        NEXT_SPAWN_SAMPLE.remove(event.getServer());
+        NEXT_TARGET.remove(event.getServer());
+        GENERATION_IN_FLIGHT.remove(event.getServer());
+    }
+
+    /** Generate at most one chunk per second across the active Age and its Overworld baseline. */
+    private static void generateNextSpawnSample(MinecraftServer server) {
+        if (GENERATION_IN_FLIGHT.containsKey(server)) return;
+        List<SampleTarget> targets = new ArrayList<>();
+        for (ServerLevel level : server.getAllLevels()) {
+            if (!PortInstabilityRuntime.isAge(level)
+                    || level.players().isEmpty()) continue;
+            var data = PortInstabilityData.get(server);
+            if (!data.supportsProfiling(level)) continue;
+            var age = data.age(level);
+            targets.add(new SampleTarget(level, age.spawn().orElseGet(() -> level.getRespawnData().pos()),
+                    PortBlockProfileSavedData.MIN_AGE_SAMPLES));
+        }
+        if (targets.isEmpty()) return;
+        ServerLevel overworld = server.overworld();
+        targets.add(0, new SampleTarget(overworld, overworld.getRespawnData().pos(),
+                PortBlockProfileSavedData.MIN_BASELINE_SAMPLES));
+        int first = Math.floorMod(NEXT_TARGET.getOrDefault(server, 0), targets.size());
+        for (int offset = 0; offset < targets.size(); offset++) {
+            int index = (first + offset) % targets.size();
+            SampleTarget target = targets.get(index);
+            if (generateNextSpawnSample(target.level(), target.origin(), target.minimum(), server)) {
+                NEXT_TARGET.put(server, index + 1);
+                return;
+            }
+        }
+    }
+
+    private static boolean generateNextSpawnSample(ServerLevel level, net.minecraft.core.BlockPos origin,
+                                                   int minimum, MinecraftServer server) {
+        PortBlockProfileSavedData profile = PortBlockProfileSavedData.get(level);
+        if (profile.count() >= minimum) return false;
+        Map<Identifier, Integer> cursors = NEXT_SPAWN_SAMPLE.computeIfAbsent(server,
+                ignored -> new HashMap<>());
+        Identifier dimension = level.dimension().identifier();
+        int index = cursors.getOrDefault(dimension, 0);
+        ChunkPos center = ChunkPos.containing(origin);
+        while (index < SPAWN_OFFSETS.size()) {
+            ChunkPos offset = SPAWN_OFFSETS.get(index++);
+            ChunkPos target = new ChunkPos(center.x() + offset.x(), center.z() + offset.z());
+            if (profile.contains(target)) continue;
+            cursors.put(dimension, index);
+            GENERATION_IN_FLIGHT.put(server, true);
+            // getChunkFuture blocks when called on the server thread. Its off-thread
+            // path schedules generation on Minecraft's chunk executor instead.
+            CompletableFuture.supplyAsync(() -> level.getChunkSource()
+                            .getChunkFuture(target.x(), target.z(), ChunkStatus.FULL, true))
+                    .thenCompose(future -> future)
+                    .whenComplete((result, error) -> {
+                        if (server.isStopped()) return;
+                        server.execute(() -> {
+                            if (GENERATION_IN_FLIGHT.remove(server) == null) return;
+                            if (error != null) {
+                                Rivencraft.LOGGER.warn("Could not profile chunk {} in {}", target, dimension, error);
+                            } else if (server.getLevel(level.dimension()) == level
+                                    && result.orElse(null) instanceof LevelChunk chunk) {
+                                profile.sample(chunk);
+                            }
+                        });
+                    });
+            return true;
+        }
+        return false;
+    }
+
+    private static List<ChunkPos> spawnOffsets() {
+        List<ChunkPos> offsets = new ArrayList<>(PortBlockProfileSavedData.MAX_SAMPLES);
+        offsets.add(new ChunkPos(0, 0));
+        for (int radius = 1; offsets.size() < PortBlockProfileSavedData.MAX_SAMPLES; radius++) {
+            for (int x = -radius; x <= radius; x++) {
+                offsets.add(new ChunkPos(x, -radius));
+                offsets.add(new ChunkPos(x, radius));
+            }
+            for (int z = -radius + 1; z < radius; z++) {
+                offsets.add(new ChunkPos(-radius, z));
+                offsets.add(new ChunkPos(radius, z));
+            }
+        }
+        return List.copyOf(offsets.subList(0, PortBlockProfileSavedData.MAX_SAMPLES));
+    }
+
+    /** Zero until the Age exceeds 400 samples and the baseline reaches 500. */
+    static int score(PortBlockProfileSavedData age, PortBlockProfileSavedData baseline) {
+        return score(age.totals(), age.count(), baseline.totals(), baseline.count());
+    }
+
+    static int score(Map<Identifier, Long> age, int ageChunks,
+                     Map<Identifier, Long> baseline, int baselineChunks) {
+        if (ageChunks < PortBlockProfileSavedData.MIN_AGE_SAMPLES
+                || baselineChunks < PortBlockProfileSavedData.MIN_BASELINE_SAMPLES) return 0;
+        double result = 0;
+        Set<Identifier> watched = new HashSet<>(age.keySet());
+        watched.addAll(baseline.keySet());
+        for (Identifier id : watched) {
+            double weight = weight(id);
+            if (weight <= 0) continue;
+            double excess = age.getOrDefault(id, 0L) / (double) ageChunks
+                    - 1.05 * baseline.getOrDefault(id, 0L) / (double) baselineChunks;
+            if (excess > 0) result += excess * weight;
+        }
+        return (int) Math.min(100_000, Math.round(result));
+    }
+
+    public static int score(ServerLevel level) {
+        if (!PortInstabilityRuntime.isAge(level) || !PortInstabilityData.get(level.getServer()).supportsProfiling(level)) return 0;
+        return score(PortBlockProfileSavedData.get(level), PortBlockProfileSavedData.get(level.getServer().overworld()));
+    }
+    public static int sampledChunks(ServerLevel level) { return PortBlockProfileSavedData.get(level).count(); }
+
+    public static int difficultyScore(long rawScore, int difficulty) {
+        double multiplier = switch (difficulty) {
+            case 0 -> 0.25;
+            case 1 -> 0.5;
+            case 2 -> 1.0;
+            case 3 -> 1.75;
+            default -> throw new IllegalArgumentException("Unknown instability difficulty " + difficulty);
+        };
+        return (int) Math.min(Integer.MAX_VALUE, Math.max(0, rawScore * multiplier));
+    }
+
+    private static Map<Identifier, Double> weights() {
+        Map<Identifier, Double> values = new HashMap<>();
+        add(values, 5, "coal_ore", "deepslate_coal_ore", "lapis_ore", "deepslate_lapis_ore");
+        add(values, 60, "iron_ore", "deepslate_iron_ore");
+        add(values, 200, "emerald_ore", "deepslate_emerald_ore");
+        add(values, 250, "redstone_ore", "deepslate_redstone_ore");
+        add(values, 750, "gold_ore", "deepslate_gold_ore");
+        add(values, 4000, "diamond_ore", "deepslate_diamond_ore", "diamond_block");
+        add(values, 20, "nether_quartz_ore");
+        add(values, 50, "glowstone");
+        values.put(Identifier.parse("rivencraft:crystal_block"), 20.0);
+        // Valuable blocks introduced after Legacy, and storage forms authorable in Rivencraft.
+        add(values, 200, "emerald_block");
+        add(values, 750, "gold_block", "raw_gold_block");
+        add(values, 4000, "ancient_debris");
+        add(values, 60, "iron_block", "raw_iron_block");
+        add(values, 8000, "netherite_block");
+        return Map.copyOf(values);
+    }
+
+    private static void add(Map<Identifier, Double> values, int weight, String... paths) {
+        for (String path : paths) values.put(Identifier.withDefaultNamespace(path), (double) weight);
+    }
+
+    private record Pending(ServerLevel level, LevelChunk chunk) {}
+
+    private record SampleTarget(ServerLevel level, net.minecraft.core.BlockPos origin, int minimum) {}
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortBlockProfileSavedData.java

@@ -0,0 +1,63 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+/** Persistent generated-chunk snapshots. Each chunk is counted once, up to the 1.21.1 cap. */
+final class PortBlockProfileSavedData extends SavedData {
+    static final int MIN_AGE_SAMPLES = 401, MIN_BASELINE_SAMPLES = 500, MAX_SAMPLES = 1024;
+    private static final int VERSION = 2;
+    private record Sample(long chunk, Map<Identifier, Integer> counts) {
+        private static final Codec<Sample> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                Codec.LONG.fieldOf("chunk").forGetter(Sample::chunk),
+                Codec.unboundedMap(Identifier.CODEC, Codec.intRange(1, Integer.MAX_VALUE))
+                        .fieldOf("blocks").forGetter(Sample::counts)
+        ).apply(instance, Sample::new));
+    }
+    private static final Codec<PortBlockProfileSavedData> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            Codec.INT.fieldOf("version").forGetter(data -> VERSION),
+            Sample.CODEC.listOf(0, MAX_SAMPLES).fieldOf("samples").forGetter(data -> data.samples.entrySet().stream()
+                    .map(entry -> new Sample(entry.getKey(), entry.getValue())).toList())
+    ).apply(instance, PortBlockProfileSavedData::new));
+    private static final SavedDataType<PortBlockProfileSavedData> TYPE = new SavedDataType<>(
+            Identifier.fromNamespaceAndPath("rivencraft", "block_profile"),
+            () -> new PortBlockProfileSavedData(VERSION, List.of()), CODEC);
+    private final Map<Long, Map<Identifier, Integer>> samples = new HashMap<>();
+    private final Map<Identifier, Long> totals = new HashMap<>();
+    private PortBlockProfileSavedData(int version, List<Sample> values) {
+        if (version == VERSION) for (var value : values) put(value.chunk(), value.counts());
+    }
+    static PortBlockProfileSavedData get(ServerLevel level) { return level.getDataStorage().computeIfAbsent(TYPE); }
+    int count() { return samples.size(); }
+    boolean contains(ChunkPos pos) { return samples.containsKey(pos.pack()); }
+    Map<Identifier, Long> totals() { return Map.copyOf(totals); }
+    boolean sample(LevelChunk chunk) {
+        if (count() >= MAX_SAMPLES || contains(chunk.getPos())) return false;
+        Map<Identifier, Integer> counts = new HashMap<>();
+        for (var section : chunk.getSections()) {
+            if (section.hasOnlyAir()) continue;
+            section.getStates().count((state, amount) -> {
+                Identifier id = BuiltInRegistries.BLOCK.getKey(state.getBlock());
+                if (PortBlockInstability.tracked(id)) counts.merge(id, amount, Integer::sum);
+            });
+        }
+        put(chunk.getPos().pack(), counts);
+        setDirty();
+        return true;
+    }
+    private void put(long pos, Map<Identifier, Integer> counts) {
+        if (count() >= MAX_SAMPLES || samples.containsKey(pos)) return;
+        samples.put(pos, Map.copyOf(counts));
+        counts.forEach((id, amount) -> totals.merge(id, amount.longValue(), Long::sum));
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortBookDropConversionProbe.java

@@ -0,0 +1,110 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.entity.DroppedBookEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.TickTask;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.ProblemReporter;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.storage.TagValueOutput;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+
+/** Join conversion runs on queued server tasks: create and inspect on separate commands. */
+final class PortBookDropConversionProbe {
+    private static final UUID OWNER = UUID.fromString("cc5909e5-aafa-43d6-b841-a917ec9c0115");
+    private static final AABB AREA = new AABB(-16, -64, -16, 32, 320, 32);
+    private static ItemStack book(boolean descriptive, String label) {
+        var stack = new ItemStack(descriptive ? Rivencraft.DESCRIPTIVE_BOOK.get() : Rivencraft.LINKING_BOOK.get());
+        stack.set(DataComponents.CUSTOM_NAME, Component.literal(label));
+        return stack;
+    }
+    static void create(ServerLevel level) {
+        for (int x = 0; x < 16; x++) for (int z = 0; z < 16; z++) level.setBlock(new BlockPos(x, 63, z), Blocks.STONE.defaultBlockState(), 2);
+        var player = net.neoforged.neoforge.common.util.FakePlayerFactory.get(level,
+                new com.mojang.authlib.GameProfile(UUID.fromString("84f38604-48fe-48d3-a4fb-f858a7200115"), "RivenDropProbe"));
+        player.setPos(8.5, 64, 8.5);
+        // Test exact factory state before physics can advance position or pickup timers.
+        var sample = new ItemEntity(level, 8.5, 66, 8.5, book(false, "state_copy"));
+        sample.getItem().set(Rivencraft.LINK_BOOK_TARGET.get(), new net.dnorberg.rivencraft.item.LinkBookTarget(
+                level.dimension().identifier(), -0.5, 64, -1.25, 135, -20));
+        sample.getItem().set(Rivencraft.LINK_DESTINATION_NAME.get(), "Named destination");
+        sample.getItem().set(Rivencraft.LINK_PROPERTIES.get(), new net.dnorberg.rivencraft.item.LinkProperties(net.dnorberg.rivencraft.item.LinkProperties.DISARM
+                | net.dnorberg.rivencraft.item.LinkProperties.MAINTAIN_MOMENTUM));
+        sample.setTarget(OWNER);
+        sample.setThrower(player);
+        sample.setPickUpDelay(80);
+        sample.setDeltaMovement(new Vec3(0.2, 0.1, -0.3));
+        sample.setYRot(37);
+        sample.setXRot(12);
+        sample.setNoGravity(true);
+        var copy = DroppedBookEntity.fromDrop(sample);
+        if (!copy.position().equals(sample.position()) || !copy.getDeltaMovement().equals(sample.getDeltaMovement())
+                || copy.getYRot() != 37 || copy.getXRot() != 12 || !copy.isNoGravity()
+                || !ItemStack.matches(copy.getItem(), sample.getItem()) || !OWNER.equals(copy.getTarget())
+                || copy.getUUID().equals(sample.getUUID()) || copy.getAge() != -32768)
+            throw new IllegalStateException("Drop conversion lost placement, ownership or item components");
+        var originalTag = TagValueOutput.createWithContext(ProblemReporter.DISCARDING, level.registryAccess());
+        var copiedTag = TagValueOutput.createWithContext(ProblemReporter.DISCARDING, level.registryAccess());
+        sample.saveWithoutId(originalTag); copy.saveWithoutId(copiedTag);
+        for (String key : List.of("PickupDelay", "Owner", "Thrower", "Item"))
+            if (!java.util.Objects.equals(originalTag.buildResult().get(key), copiedTag.buildResult().get(key)))
+                throw new IllegalStateException("Drop conversion lost metadata: " + key);
+        // Four ordinary book variants must all convert through the actual event route.
+        for (String name : List.of("manual_link", "manual_description", "unwritten_link", "unwritten_description")) {
+            var stack = book(name.endsWith("description"), name);
+            if (name.equals("manual_link")) {
+                stack.set(Rivencraft.LINK_BOOK_TARGET.get(), sample.getItem().get(Rivencraft.LINK_BOOK_TARGET.get()));
+                stack.set(Rivencraft.LINK_DESTINATION_NAME.get(), "Named destination");
+            }
+            if (name.equals("manual_description")) stack.set(Rivencraft.AGE_BOOK_ID.get(), level.dimension().identifier());
+            var item = new ItemEntity(level, 8.5, 66, 8.5, stack);
+            item.setNoGravity(true); item.setDeltaMovement(Vec3.ZERO); item.setTarget(OWNER);
+            level.addFreshEntity(item);
+        }
+        player.drop(book(false, "player_toss"), false, net.minecraft.util.Prediction.SERVER_ONLY);
+        net.minecraft.world.Containers.dropItemStack(level, 8.5, 65, 8.5, book(true, "container"));
+        var standPos = new BlockPos(10, 64, 8);
+        level.setBlock(standPos, Rivencraft.BOOK_STAND.get().defaultBlockState(), 3);
+        ((net.dnorberg.rivencraft.block.entity.BookStandBlockEntity) level.getBlockEntity(standPos)).setBook(book(false, "stand"));
+        level.destroyBlock(standPos, true);
+        var custom = new DroppedBookEntity(level, new Vec3(8.5, 66, 8.5), book(false, "already_custom"));
+        custom.setNoGravity(true);
+        level.addFreshEntity(custom);
+        level.addFreshEntity(new ItemEntity(level, 8.5, 66, 8.5, net.dnorberg.rivencraft.item.PageItem.createLinkPanelPage()));
+        java.util.function.Consumer<net.neoforged.neoforge.event.entity.EntityJoinLevelEvent> cancel = event -> {
+            if (event.getLevel() == level && event.getEntity() instanceof DroppedBookEntity dropped
+                    && dropped.getItem().getHoverName().getString().equals("cancel_preserve")) event.setCanceled(true);
+        };
+        net.neoforged.neoforge.common.NeoForge.EVENT_BUS.addListener(cancel);
+        try {
+            var item = new ItemEntity(level, 8.5, 66, 8.5, book(false, "cancel_preserve"));
+            item.setNoGravity(true); item.setDeltaMovement(Vec3.ZERO);
+            level.addFreshEntity(item);
+        } finally {
+            // Queued after that source's conversion task; no fixture listener remains installed.
+            level.getServer().schedule(new TickTask(0, () -> net.neoforged.neoforge.common.NeoForge.EVENT_BUS.unregister(cancel)));
+        }
+    }
+    static void verify(ServerLevel level) {
+        var drops = level.getEntitiesOfClass(ItemEntity.class, AREA);
+        for (String name : List.of("manual_link", "manual_description", "unwritten_link", "unwritten_description",
+                "player_toss", "container", "stand", "already_custom", "cancel_preserve")) {
+            var found = drops.stream().filter(e -> e.getItem().getHoverName().getString().equals(name)).toList();
+            if (found.size() != 1 || !name.equals("cancel_preserve") && !(found.getFirst() instanceof DroppedBookEntity))
+                throw new IllegalStateException("Expected one open book for " + name + ", found " + found.size());
+        }
+        var named = drops.stream().filter(e -> e.getItem().getHoverName().getString().equals("manual_link")).findFirst().orElseThrow();
+        if (!OWNER.equals(named.getTarget()) || !"Named destination".equals(named.getItem().get(Rivencraft.LINK_DESTINATION_NAME.get())))
+            throw new IllegalStateException("Converted book lost owner or destination");
+        if (drops.stream().filter(e -> e.getItem().is(Rivencraft.PAGE.get())).anyMatch(e -> e instanceof DroppedBookEntity))
+            throw new IllegalStateException("Non-book item was converted");
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortBookStandProbe.java

@@ -0,0 +1,93 @@
+package net.dnorberg.rivencraft.age;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.BookStandBlock;
+import net.dnorberg.rivencraft.block.entity.BookStandBlockEntity;
+import net.dnorberg.rivencraft.event.BookStandConversionHandler;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.network.PortBookNetworking;
+import net.dnorberg.rivencraft.network.UseBookStandPayload;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.LecternBlock;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.Vec3;
+
+/** Isolated conversion, ownership, stale-screen and persistence checks. */
+final class PortBookStandProbe {
+    private static final BlockPos POS = new BlockPos(0, 64, 0);
+    static void create(ServerLevel level) {
+        var player = net.neoforged.neoforge.common.util.FakePlayerFactory.get(level,
+                new com.mojang.authlib.GameProfile(java.util.UUID.fromString("a5c323a1-3b58-4dd6-927f-e08000800110"), "RivenStandProbe"));
+        player.setPos(0.5, 64, 2.5);
+        try {
+            for (Direction facing : Direction.Plane.HORIZONTAL) for (InteractionHand hand : InteractionHand.values())
+                for (var sample : java.util.List.of(new ItemStack(Rivencraft.LINKING_BOOK.get()),
+                        new ItemStack(Rivencraft.DESCRIPTIVE_BOOK.get()), PageItem.createLinkPanelPage().copyWithCount(3))) {
+                    level.setBlock(POS, Blocks.LECTERN.defaultBlockState().setValue(LecternBlock.FACING, facing), 3);
+                    player.setItemInHand(hand, sample.copy());
+                    if (!BookStandConversionHandler.convert(player, hand, POS)) throw new IllegalStateException("Conversion failed");
+                    var stand = (BookStandBlockEntity) level.getBlockEntity(POS);
+                    var stored = sample.copyWithCount(1);
+                    if (!ItemStack.matches(stand.getBook(), stored) || player.getItemInHand(hand).getCount() != sample.getCount() - 1
+                            || stand.getBlockState().getValue(BookStandBlock.FACING) != facing)
+                        throw new IllegalStateException("Conversion lost ownership or facing");
+                    var packet = new UseBookStandPayload(level.dimension().identifier(), POS, stored.copy());
+                    if (PortBookNetworking.validatedStandBook(player, packet).isEmpty()) throw new IllegalStateException("Valid source rejected");
+                    player.setPos(100, 64, 100);
+                    if (!PortBookNetworking.validatedStandBook(player, packet).isEmpty()) throw new IllegalStateException("Distant source accepted");
+                    player.setPos(0.5, 64, 2.5);
+                    if (!PortBookNetworking.validatedStandBook(player, new UseBookStandPayload(
+                            net.minecraft.resources.Identifier.fromNamespaceAndPath("minecraft", "overworld"), POS, stored)).isEmpty())
+                        throw new IllegalStateException("Wrong dimension accepted");
+                    if (!PortBookNetworking.validatedStandBook(player, new UseBookStandPayload(packet.dimension(), POS, new ItemStack(Items.DIRT))).isEmpty())
+                        throw new IllegalStateException("Replaced book accepted");
+                    var loaded = net.minecraft.world.level.block.entity.BlockEntity.loadStatic(POS, stand.getBlockState(),
+                            stand.saveWithFullMetadata(level.registryAccess()), level.registryAccess());
+                    if (!(loaded instanceof BookStandBlockEntity copy) || !ItemStack.matches(copy.getBook(), stored))
+                        throw new IllegalStateException("Stand serialization lost content");
+                    player.getInventory().clearContent();
+                    player.setShiftKeyDown(true);
+                    stand.getBlockState().useWithoutItem(level, player, new BlockHitResult(Vec3.atCenterOf(POS), Direction.UP, POS, false));
+                    player.setShiftKeyDown(false);
+                    if (!level.getBlockState(POS).is(Blocks.LECTERN)
+                            || level.getBlockState(POS).getValue(LecternBlock.FACING) != facing
+                            || player.getInventory().countItem(stored.getItem()) != 1
+                            || !PortBookNetworking.validatedStandBook(player, packet).isEmpty())
+                        throw new IllegalStateException("Retrieval did not restore lectern or recover item exactly once");
+                    player.getInventory().clearContent();
+                    player.setItemInHand(hand, stored.copy());
+                    BookStandConversionHandler.convert(player, hand, POS);
+                    level.destroyBlock(POS, true);
+                    var drops = level.getEntitiesOfClass(net.minecraft.world.entity.item.ItemEntity.class,
+                            new net.minecraft.world.phys.AABB(-2, 62, -2, 3, 68, 3));
+                    int items = drops.stream().filter(e -> e.getItem().is(stored.getItem())).mapToInt(e -> e.getItem().getCount()).sum();
+                    int lecterns = drops.stream().filter(e -> e.getItem().is(Items.LECTERN)).mapToInt(e -> e.getItem().getCount()).sum();
+                    if (items != 1 || lecterns != 1) throw new IllegalStateException("Break drops duplicated/lost: " + items + "/" + lecterns);
+                    drops.forEach(net.minecraft.world.entity.Entity::discard);
+                }
+            level.setBlock(POS, Blocks.LECTERN.defaultBlockState().setValue(LecternBlock.HAS_BOOK, true), 3);
+            player.setItemInHand(InteractionHand.MAIN_HAND, PageItem.createLinkPanelPage());
+            if (BookStandConversionHandler.convert(player, InteractionHand.MAIN_HAND, POS)) throw new IllegalStateException("Occupied lectern converted");
+            level.setBlock(POS, Blocks.LECTERN.defaultBlockState(), 3);
+            player.setItemInHand(InteractionHand.MAIN_HAND, new ItemStack(Items.DIRT));
+            if (BookStandConversionHandler.convert(player, InteractionHand.MAIN_HAND, POS)) throw new IllegalStateException("Unrelated item accepted");
+            var named = new ItemStack(Rivencraft.LINKING_BOOK.get());
+            named.set(net.minecraft.core.component.DataComponents.CUSTOM_NAME, net.minecraft.network.chat.Component.literal("Stand persistence"));
+            player.setItemInHand(InteractionHand.MAIN_HAND, named);
+            if (!BookStandConversionHandler.convert(player, InteractionHand.MAIN_HAND, POS)) throw new IllegalStateException("Final stand missing");
+        } finally { player.setShiftKeyDown(false); player.getInventory().clearContent(); }
+        verify(level);
+    }
+    static void verify(ServerLevel level) {
+        if (!(level.getBlockEntity(POS) instanceof BookStandBlockEntity stand)
+                || !stand.getBook().is(Rivencraft.LINKING_BOOK.get())
+                || !stand.getBook().getHoverName().getString().equals("Stand persistence"))
+            throw new IllegalStateException("Stand restart persistence failed");
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortCarverPages.java

@@ -0,0 +1,78 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.QuartPos;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.tags.BiomeTags;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.CarvingMask;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.LegacyRandomSource;
+import net.minecraft.world.level.levelgen.RandomState;
+import net.minecraft.world.level.levelgen.WorldGenerationContext;
+import net.minecraft.world.level.levelgen.WorldgenRandom;
+import net.minecraft.world.level.levelgen.carver.WorldCarver;
+
+/** Authored Caves/Ravines, independent of the terrain page, with 1.21.1 source seeds. */
+public final class PortCarverPages {
+    public static final Identifier CAVES = Identifier.fromNamespaceAndPath("rivencraft", "feature/caves");
+    public static final Identifier RAVINES = Identifier.fromNamespaceAndPath("rivencraft", "feature/ravines");
+    private static final long CAVE_SALT = 0x4341564553464541L;
+    private static final long RAVINE_SALT = 0x524156494E45534CL;
+
+    private PortCarverPages() {}
+
+    public static boolean supports(Identifier page) { return CAVES.equals(page) || RAVINES.equals(page); }
+
+    public static void validateCounts(List<Identifier> pages) {
+        Map<Identifier, Integer> counts = new HashMap<>();
+        for (Identifier page : pages) if (!supports(page) || counts.merge(page, 1, Integer::sum) > 32)
+            throw new IllegalArgumentException("Carver plan requires Caves/Ravines pages, at most 32 per type");
+    }
+
+    public static void validateRegistry(List<Identifier> pages, HolderLookup.Provider registries) {
+        if (pages.stream().noneMatch(PortCarverPages::supports)) return;
+        var carvers = registries.lookupOrThrow(Registries.CARVER);
+        for (String name : pages.contains(CAVES) ? List.of("cave", "nether_cave", "canyon") : List.of("canyon")) {
+            if (name.equals("canyon") && !pages.contains(RAVINES)) continue;
+            carvers.get(ResourceKey.create(Registries.CARVER, Identifier.withDefaultNamespace(name)))
+                    .orElseThrow(() -> new IllegalArgumentException("Missing authored carver minecraft:" + name));
+        }
+    }
+
+    public static void carve(ChunkGenerator generator, ChunkAccess chunk, RandomState randomState,
+                             HolderLookup.Provider registries, List<Identifier> pages, long seed, CarvingMask mask) {
+        if (pages.isEmpty()) return;
+        var registry = registries.lookupOrThrow(Registries.CARVER);
+        var biomes = generator.getBiomeSource().createUncachedResolver(randomState);
+        var context = new WorldGenerationContext(generator, chunk.getHeightAccessorForGeneration());
+        var random = new WorldgenRandom(new LegacyRandomSource(0L));
+        ChunkPos target = chunk.getPos();
+        // 1.21.1 repeats identical seeds for duplicate Caves/Ravines pages.
+        // Their union is identical; avoid replaying the same mask up to 32 times.
+        for (Identifier page : pages.stream().distinct().toList()) {
+            boolean ravine = page.equals(RAVINES);
+            WorldCarver overworld = registry.getOrThrow(ResourceKey.create(Registries.CARVER,
+                    Identifier.withDefaultNamespace(ravine ? "canyon" : "cave"))).value();
+            WorldCarver nether = ravine ? null : registry.getOrThrow(ResourceKey.create(Registries.CARVER,
+                    Identifier.withDefaultNamespace("nether_cave"))).value();
+            for (int dx = -8; dx <= 8; dx++) {
+                for (int dz = -8; dz <= 8; dz++) {
+                    ChunkPos source = new ChunkPos(target.x() + dx, target.z() + dz);
+                    boolean isNether = biomes.getNoiseBiome(QuartPos.fromBlock(source.getMinBlockX()), 0,
+                            QuartPos.fromBlock(source.getMinBlockZ())).is(BiomeTags.IS_NETHER);
+                    if (ravine && isNether) continue;
+                    WorldCarver carver = isNether ? nether : overworld;
+                    random.setLargeFeatureSeed(seed ^ (ravine ? RAVINE_SALT : CAVE_SALT), source.x(), source.z());
+                    if (carver.isStartChunk(random)) carver.carve(context, random, target, source, mask);
+                }
+            }
+        }
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortCelestialBody.java

@@ -0,0 +1,96 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+
+/** One frozen authored orbit, using the same angular motion as 1.21.1 Body. */
+public record PortCelestialBody(int kind, double period, int stoppedTime, long originTick,
+                                int phaseTick, boolean clockwise, int bearing, float size, int color) {
+    public static final Codec<PortCelestialBody> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            Codec.intRange(1, 2).fieldOf("kind").forGetter(PortCelestialBody::kind),
+            Codec.doubleRange(0, 2).fieldOf("period").forGetter(PortCelestialBody::period),
+            Codec.intRange(0, 23999).fieldOf("stopped_time").forGetter(PortCelestialBody::stoppedTime),
+            Codec.LONG.fieldOf("origin_tick").forGetter(PortCelestialBody::originTick),
+            Codec.intRange(0, 23999).fieldOf("phase_tick").forGetter(PortCelestialBody::phaseTick),
+            Codec.BOOL.fieldOf("clockwise").forGetter(PortCelestialBody::clockwise),
+            Codec.intRange(-1, 359).fieldOf("bearing").forGetter(PortCelestialBody::bearing),
+            Codec.floatRange(0.25F, 3F).fieldOf("size").forGetter(PortCelestialBody::size),
+            Codec.intRange(-1, 0xffffff).fieldOf("color").forGetter(PortCelestialBody::color)
+    ).apply(instance, PortCelestialBody::new));
+    public static final StreamCodec<RegistryFriendlyByteBuf, PortCelestialBody> STREAM_CODEC = StreamCodec.composite(
+            ByteBufCodecs.VAR_INT, PortCelestialBody::kind, ByteBufCodecs.DOUBLE, PortCelestialBody::period,
+            ByteBufCodecs.VAR_INT, PortCelestialBody::stoppedTime, ByteBufCodecs.VAR_LONG, PortCelestialBody::originTick,
+            ByteBufCodecs.VAR_INT, PortCelestialBody::phaseTick, ByteBufCodecs.BOOL, PortCelestialBody::clockwise,
+            ByteBufCodecs.INT, PortCelestialBody::bearing, ByteBufCodecs.FLOAT, PortCelestialBody::size,
+            ByteBufCodecs.INT, PortCelestialBody::color, PortCelestialBody::new);
+
+    public PortCelestialBody {
+        if (kind != PortDayCycle.SUN && kind != PortDayCycle.MOON || !Double.isFinite(period)
+                || period < 0 || period > 2 || stoppedTime < 0 || stoppedTime >= 24000
+                || phaseTick < 0 || phaseTick >= 24000 || bearing < -1 || bearing > 359
+                || !Float.isFinite(size) || size < 0.25F || size > 3 || color < -1 || color > 0xffffff)
+            throw new IllegalArgumentException("Invalid celestial body");
+    }
+
+    public static PortCelestialBody of(PortDayCycle cycle, int kind, int color, boolean pairedMoon) {
+        int offset = pairedMoon ? 12000 : 0;
+        return new PortCelestialBody(kind, cycle.period(), (cycle.stoppedTime() + offset) % 24000,
+                cycle.originTick(), (cycle.phaseTick() + offset) % 24000, cycle.clockwise(),
+                cycle.bearing(), pairedMoon ? 1F : cycle.sunSize(), color);
+    }
+
+    public float angle(double nativeTicks) {
+        double time = period == 0 ? stoppedTime
+                : (clockwise ? 1 : -1) * (nativeTicks - originTick) / period + phaseTick;
+        return (float) (((time - 6000D) % 24000D) * (360D / 24000D));
+    }
+
+    public float light(long nativeTicks) {
+        return Math.max(0F, (float) Math.cos(Math.toRadians(angle(nativeTicks))))
+                * (kind == PortDayCycle.MOON ? 0.18F : 1F);
+    }
+
+    public net.minecraft.world.phys.Vec3 direction(double ticks) {
+        double orbit = Math.toRadians(angle(ticks)), axis = Math.toRadians(bearing < 0 ? -90 : bearing);
+        double lateral = Math.sin(orbit);
+        return new net.minecraft.world.phys.Vec3(Math.sin(axis) * lateral, Math.cos(orbit), Math.cos(axis) * lateral);
+    }
+
+    /** Root AgeSkyProfile.eclipseFor: contact uses the central quarter-size disc, not its halo. */
+    public float eclipse(java.util.List<PortCelestialBody> bodies, double ticks) {
+        float strongest = 0;
+        var direction = direction(ticks);
+        double radius = Math.atan((kind == PortDayCycle.SUN ? 30D : 20D) * size * 0.25D / 100D);
+        for (var other : bodies) {
+            if (other.kind == kind) continue;
+            double separation = Math.acos(Math.max(-1D, Math.min(1D, direction.dot(other.direction(ticks)))));
+            double contact = radius + Math.atan((other.kind == PortDayCycle.SUN ? 30D : 20D) * other.size * 0.25D / 100D);
+            strongest = Math.max(strongest, (float) Math.max(0D, 1D - separation / contact));
+        }
+        return strongest;
+    }
+
+    public static float eclipseAt(java.util.List<PortCelestialBody> bodies, double ticks) {
+        float strongest = 0;
+        for (var body : bodies) if (body.kind == PortDayCycle.SUN && body.direction(ticks).y > 0D)
+            strongest = Math.max(strongest, body.eclipse(bodies, ticks));
+        return strongest;
+    }
+
+    /** Shared client/server-checkable RGB rule; alpha is handled by the renderer. */
+    public int eclipseColor(float eclipse) {
+        int rgb = color < 0 ? 0xffffff : color;
+        float corona = kind == PortDayCycle.SUN ? (float) Math.pow(eclipse, 8D) * 0.8F : 0F;
+        int red = channel(rgb >> 16 & 255, eclipse, corona);
+        int green = channel(rgb >> 8 & 255, eclipse, corona);
+        int blue = channel(rgb & 255, eclipse, corona);
+        return red << 16 | green << 8 | blue;
+    }
+
+    private int channel(int value, float eclipse, float corona) {
+        return Math.round(kind == PortDayCycle.MOON ? value * (1F - eclipse) : value + (255 - value) * corona);
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortCollectionExtrasProbe.java

@@ -0,0 +1,109 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.item.SymbolPortfolioItem;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.writing.PortSymbolPages;
+import net.minecraft.core.BlockPos;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.Container;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.phys.AABB;
+
+/** Disposable-world boundary, booster-use and persistence checks. */
+final class PortCollectionExtrasProbe {
+    private static final BlockPos CHEST = new BlockPos(0, 64, 0);
+    private PortCollectionExtrasProbe() {}
+    private static Identifier id(String path) { return Identifier.fromNamespaceAndPath("rivencraft", path); }
+    private static NotebookContents contents(ItemStack stack) { return stack.get(Rivencraft.NOTEBOOK_CONTENTS.get()); }
+    private static List<Identifier> symbols(ItemStack collection) {
+        return contents(collection).pages().stream().map(page -> page.get(Rivencraft.SYMBOL_PAGE_ID.get())).toList();
+    }
+    private static void folder(ItemStack stack) {
+        if (!stack.is(Rivencraft.COLLATION_FOLDER.get()) || contents(stack).pageCount() != 16
+                || symbols(stack).stream().anyMatch(id -> !PortSymbolPages.sealedCandidateIds().contains(id)))
+            throw new IllegalStateException("Sealed Notebook page pool/count regression");
+    }
+
+    static void create(ServerLevel level) {
+        PortAgeTravel.findLanding(level);
+        level.setBlock(CHEST, Blocks.CHEST.defaultBlockState(), 3);
+        var chest = (Container) level.getBlockEntity(CHEST);
+        var pages = new java.util.ArrayList<ItemStack>();
+        for (int i = 0; i < 253; i++) pages.add(PageItem.createSymbolPage(id(i % 2 == 0 ? "terrain/flat" : "weather/off")));
+        var volumes = SymbolPortfolioItem.createVolumes(id("feature"), pages);
+        if (volumes.size() != 2 || contents(volumes.get(0)).pageCount() != 252
+                || contents(volumes.get(1)).pageCount() != 1
+                || !volumes.stream().flatMap(volume -> symbols(volume).stream()).toList()
+                        .equals(pages.stream().map(page -> page.get(Rivencraft.SYMBOL_PAGE_ID.get())).toList())
+                || !SymbolPortfolioItem.createVolumes(id("feature"), List.of()).isEmpty())
+            throw new IllegalStateException("Portfolio volume boundary/order regression");
+        chest.setItem(0, volumes.get(0));
+        chest.setItem(1, volumes.get(1));
+        var actual = net.dnorberg.rivencraft.registry.ModCreativeTabs.creativeSymbolPortfolios(level.registryAccess());
+        var allPages = PortSymbolPages.categories().stream().flatMap(category -> PortSymbolPages.pages(category, level.registryAccess()).stream())
+                .map(page -> page.get(Rivencraft.SYMBOL_PAGE_ID.get())).toList();
+        if (!actual.stream().flatMap(volume -> symbols(volume).stream()).toList().equals(allPages))
+            throw new IllegalStateException("Creative portfolios omit/duplicate/reorder pages");
+        var player = net.neoforged.neoforge.common.util.FakePlayerFactory.get(level,
+                new com.mojang.authlib.GameProfile(java.util.UUID.fromString("790b69dd-b62b-45be-9017-caf16515169a"), "RivenExtrasProbe"));
+        player.setPos(0.5, 64, 2.5);
+        try {
+            player.getAbilities().instabuild = false;
+            player.getRandom().setSeed(105);
+            var first = net.dnorberg.rivencraft.item.SealedNotebookItem.open(player);
+            player.getRandom().setSeed(105);
+            var repeat = net.dnorberg.rivencraft.item.SealedNotebookItem.open(player);
+            folder(first);
+            if (!symbols(first).equals(symbols(repeat))) throw new IllegalStateException("Booster seeded selection changed");
+            chest.setItem(2, first);
+            for (var hand : InteractionHand.values()) {
+                player.getInventory().clearContent();
+                player.setItemInHand(InteractionHand.OFF_HAND, ItemStack.EMPTY);
+                player.setItemInHand(hand, new ItemStack(Rivencraft.SEALED_NOTEBOOK.get()));
+                Rivencraft.SEALED_NOTEBOOK.get().use(level, player, hand);
+                folder(player.getItemInHand(hand));
+            }
+            player.getInventory().clearContent();
+            player.setItemInHand(InteractionHand.OFF_HAND, ItemStack.EMPTY);
+            player.setItemInHand(InteractionHand.MAIN_HAND, new ItemStack(Rivencraft.SEALED_NOTEBOOK.get(), 2));
+            Rivencraft.SEALED_NOTEBOOK.get().use(level, player, InteractionHand.MAIN_HAND);
+            if (player.getMainHandItem().getCount() != 1) throw new IllegalStateException("Booster stack consumption regression");
+            player.getAbilities().instabuild = true;
+            Rivencraft.SEALED_NOTEBOOK.get().use(level, player, InteractionHand.MAIN_HAND);
+            if (!player.getMainHandItem().is(Rivencraft.SEALED_NOTEBOOK.get()) || player.getMainHandItem().getCount() != 1)
+                throw new IllegalStateException("Creative booster consumed its input");
+            player.getAbilities().instabuild = false;
+            for (int slot = 0; slot < player.getInventory().getContainerSize(); slot++)
+                player.getInventory().setItem(slot, new ItemStack(Items.COBBLESTONE, 64));
+            player.setItemInHand(InteractionHand.MAIN_HAND, new ItemStack(Rivencraft.SEALED_NOTEBOOK.get(), 2));
+            Rivencraft.SEALED_NOTEBOOK.get().use(level, player, InteractionHand.MAIN_HAND);
+            var dropped = level.getEntitiesOfClass(ItemEntity.class, new AABB(-3, 60, -3, 4, 70, 6),
+                    entity -> entity.getItem().is(Rivencraft.COLLATION_FOLDER.get()));
+            if (dropped.size() != 1 || player.getMainHandItem().getCount() != 1)
+                throw new IllegalStateException("Full-inventory booster delivery regression");
+            folder(dropped.getFirst().getItem());
+            dropped.getFirst().discard();
+        } finally {
+            player.getAbilities().instabuild = false;
+            player.getInventory().clearContent();
+            player.setItemInHand(InteractionHand.OFF_HAND, ItemStack.EMPTY);
+        }
+        verify(level);
+    }
+
+    static void verify(ServerLevel level) {
+        if (!(level.getBlockEntity(CHEST) instanceof Container chest)) throw new IllegalStateException("Fixture chest missing");
+        if (!chest.getItem(0).is(Rivencraft.SYMBOL_PORTFOLIO.get()) || contents(chest.getItem(0)).pageCount() != 252
+                || !chest.getItem(1).is(Rivencraft.SYMBOL_PORTFOLIO.get()) || contents(chest.getItem(1)).pageCount() != 1)
+            throw new IllegalStateException("Portfolio persistence regression");
+        folder(chest.getItem(2));
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortCrystalFormationsFeature.java

@@ -0,0 +1,78 @@
+package net.dnorberg.rivencraft.age;
+
+import net.dnorberg.rivencraft.Rivencraft;
+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;
+
+/** 26.3 port of the 1.21.1 surface crystal mound with budding hearts and seeded buds. */
+final class PortCrystalFormationsFeature {
+    private static final long SALT = 0x4352595354414C53L;
+    private static final int CHANCE = 15;
+
+    private PortCrystalFormationsFeature() {}
+
+    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.getMinY() + 1 || y + 4 >= level.getMaxY()) 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 ? Rivencraft.BUDDING_CRYSTAL.get().defaultBlockState()
+                                    : Rivencraft.CRYSTAL_BLOCK.get().defaultBlockState(), 2);
+                }
+                if (level.getBlockState(pos.set(site.x() + dx, y + height - 1, site.z() + dz))
+                        .is(Rivencraft.BUDDING_CRYSTAL) && random.nextBoolean()) {
+                    level.setBlock(pos.set(site.x() + dx, y + height, site.z() + dz),
+                            Rivencraft.SMALL_CRYSTAL_BUD.get().defaultBlockState()
+                                    .setValue(AmethystClusterBlock.FACING, Direction.UP), 2);
+                }
+            }
+        }
+    }
+
+    private static long mix(long value) {
+        value = (value ^ value >>> 30) * 0xBF58476D1CE4E5B9L;
+        value = (value ^ value >>> 27) * 0x94D049BB133111EBL;
+        return value ^ value >>> 31;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortDayCycle.java

@@ -0,0 +1,343 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import net.minecraft.core.Holder;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.clock.ClockInstance;
+import net.minecraft.world.clock.ClockManager;
+import net.minecraft.world.clock.WorldClock;
+import net.minecraft.world.clock.WorldClocks;
+import net.minecraft.world.level.Level;
+
+/** Authored native celestial controls. Never mutates the shared clock. */
+public record PortDayCycle(boolean authored, double period, int stoppedTime,
+                           long originTick, int phaseTick, boolean clockwise, int bearing, float sunSize, int bodyMode,
+                           List<PortCelestialBody> bodies) {
+    public static final int PAIRED = 0, SUN = 1, MOON = 2, NONE = 3;
+    public static final PortDayCycle NATIVE = new PortDayCycle(false, 1, 0);
+    public static final Identifier NORMAL_TIME = Identifier.fromNamespaceAndPath("rivencraft", "celestial/normal_time");
+    public static final Codec<PortDayCycle> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            Codec.BOOL.fieldOf("authored").forGetter(PortDayCycle::authored),
+            Codec.doubleRange(0, 2).fieldOf("period").forGetter(PortDayCycle::period),
+            Codec.intRange(0, 23999).fieldOf("stopped_time").forGetter(PortDayCycle::stoppedTime),
+            Codec.LONG.optionalFieldOf("origin_tick", 0L).forGetter(PortDayCycle::originTick),
+            Codec.intRange(0, 23999).optionalFieldOf("phase_tick", 0).forGetter(PortDayCycle::phaseTick),
+            Codec.BOOL.optionalFieldOf("clockwise", true).forGetter(PortDayCycle::clockwise),
+            Codec.intRange(-1, 359).optionalFieldOf("bearing", -1).forGetter(PortDayCycle::bearing),
+            Codec.floatRange(0.25F, 3F).optionalFieldOf("sun_size", 1F).forGetter(PortDayCycle::sunSize),
+            Codec.intRange(0, 3).optionalFieldOf("body_mode", PAIRED).forGetter(PortDayCycle::bodyMode),
+            PortCelestialBody.CODEC.listOf().optionalFieldOf("bodies", List.of()).forGetter(PortDayCycle::bodies)
+    ).apply(instance, PortDayCycle::new));
+    public static final StreamCodec<RegistryFriendlyByteBuf, PortDayCycle> STREAM_CODEC = StreamCodec.composite(
+            ByteBufCodecs.BOOL, PortDayCycle::authored, ByteBufCodecs.DOUBLE, PortDayCycle::period,
+            ByteBufCodecs.VAR_INT, PortDayCycle::stoppedTime, ByteBufCodecs.VAR_LONG, PortDayCycle::originTick,
+            ByteBufCodecs.VAR_INT, PortDayCycle::phaseTick, ByteBufCodecs.BOOL, PortDayCycle::clockwise,
+            ByteBufCodecs.INT, PortDayCycle::bearing, ByteBufCodecs.FLOAT, PortDayCycle::sunSize,
+            ByteBufCodecs.VAR_INT, PortDayCycle::bodyMode,
+            PortCelestialBody.STREAM_CODEC.apply(ByteBufCodecs.list()), PortDayCycle::bodies, PortDayCycle::new);
+    private static volatile Map<Identifier, PortDayCycle> clientCycles = Map.of();
+
+    public PortDayCycle {
+        bodies = List.copyOf(bodies);
+        if (!Double.isFinite(period) || period < 0 || period > 2 || stoppedTime < 0 || stoppedTime >= 24000
+                || phaseTick < 0 || phaseTick >= 24000 || bearing < -1 || bearing >= 360
+                || !Float.isFinite(sunSize) || sunSize < 0.25F || sunSize > 3F
+                || bodyMode < PAIRED || bodyMode > NONE
+                || bodyMode == NONE && (!authored || !bodies.isEmpty()))
+            throw new IllegalArgumentException("Invalid day cycle");
+        if (bodies.stream().filter(body -> body.kind() == SUN).count() > 10
+                || bodies.stream().filter(body -> body.kind() == MOON).count() > 10)
+            throw new IllegalArgumentException("An Age may have at most ten suns and ten moons");
+    }
+
+    public PortDayCycle(boolean authored, double period, int stoppedTime,
+                        long originTick, int phaseTick, boolean clockwise, int bearing, float sunSize, int bodyMode) {
+        this(authored, period, stoppedTime, originTick, phaseTick, clockwise, bearing, sunSize, bodyMode, List.of());
+    }
+
+    public PortDayCycle(boolean authored, double period, int stoppedTime,
+                        long originTick, int phaseTick, boolean clockwise, int bearing, float sunSize) {
+        this(authored, period, stoppedTime, originTick, phaseTick, clockwise, bearing, sunSize, PAIRED);
+    }
+
+    public PortDayCycle(boolean authored, double period, int stoppedTime) {
+        this(authored, period, stoppedTime, 0, 0, true);
+    }
+
+    public PortDayCycle(boolean authored, double period, int stoppedTime,
+                        long originTick, int phaseTick, boolean clockwise) {
+        this(authored, period, stoppedTime, originTick, phaseTick, clockwise, -1);
+    }
+
+    public PortDayCycle(boolean authored, double period, int stoppedTime,
+                        long originTick, int phaseTick, boolean clockwise, int bearing) {
+        this(authored, period, stoppedTime, originTick, phaseTick, clockwise, bearing, 1F);
+    }
+
+    public static boolean isPeriod(Identifier page) {
+        return page.getNamespace().equals("rivencraft") && switch (page.getPath()) {
+            case "period/full", "period/half", "period/double", "period/zero" -> true;
+            default -> false;
+        };
+    }
+
+    public static boolean isPhase(Identifier page) {
+        return page.getNamespace().equals("rivencraft") && switch (page.getPath()) {
+            case "phase/rising", "phase/zenith", "phase/setting", "phase/nadir" -> true;
+            default -> false;
+        };
+    }
+
+    public static boolean isDirection(Identifier page) {
+        return page.getNamespace().equals("rivencraft") && (page.getPath().equals("direction/clockwise")
+                || page.getPath().equals("direction/counterclockwise"));
+    }
+
+    public static boolean isAngle(Identifier page) {
+        return page.getNamespace().equals("rivencraft") && switch (page.getPath()) {
+            case "angle/north", "angle/east", "angle/south", "angle/west" -> true;
+            default -> false;
+        };
+    }
+
+    public static boolean supports(Identifier page) {
+        return isController(page) || isPeriod(page) || isPhase(page) || isDirection(page) || isAngle(page) || isSize(page);
+    }
+
+    public static boolean isController(Identifier page) {
+        return page.getNamespace().equals("rivencraft") && switch (page.getPath()) {
+            case "celestial/normal_time", "celestial/sun", "celestial/moon" -> true;
+            default -> false;
+        };
+    }
+
+    public static boolean isSize(Identifier page) {
+        return page.getNamespace().equals("rivencraft") && switch (page.getPath()) {
+            case "size/small", "size/normal", "size/large" -> true;
+            default -> false;
+        };
+    }
+
+    public static boolean validWriting(List<Identifier> pages) {
+        int suns = 0, moons = 0;
+        for (Identifier page : pages) if (isController(page)) {
+            if (!page.getPath().equals("celestial/moon")) suns++;
+            if (!page.getPath().equals("celestial/sun")) moons++;
+            if (suns > 10 || moons > 10) return false;
+        }
+        // Repeated modifiers overwrite the pending value. Unconsumed modifiers
+        // earn grammar instability, but never affect an earlier body.
+        return true;
+    }
+
+    public static PortDayCycle compile(List<Identifier> pages, long seed) {
+        return compile(pages, seed, 0);
+    }
+
+    /** Creation-only completion. Exact diagnostic fixtures can still use compile. */
+    public static PortDayCycle resolve(List<Identifier> pages, long seed, long nativeTicks) {
+        if (!validWriting(pages))
+            throw new IllegalArgumentException("An Age may have at most ten suns and ten moons");
+        if (pages.stream().anyMatch(PortDayCycle::isController)) return compile(pages, seed, nativeTicks);
+        // Match root AgeSkyProfile.random's count draw positions: sky style,
+        // mixed sky color, then independent 0..3 sun and moon counts.
+        var random = new Random(seed ^ 0x534B5950524F464CL);
+        random.nextInt(5);
+        randomColor(random);
+        int suns = random.nextInt(4), moons = random.nextInt(4);
+        var bodies = new java.util.ArrayList<PortCelestialBody>();
+        for (int i = 0; i < suns + moons; i++)
+            bodies.addAll(randomUnmodified(seed, i, nativeTicks, i < suns ? SUN : MOON).bodies);
+        if (bodies.isEmpty()) return new PortDayCycle(true, 1, 0, 0, 0, true, -1, 1F, NONE);
+        var first = bodies.getFirst();
+        return new PortDayCycle(true, first.period(), first.stoppedTime(), first.originTick(), first.phaseTick(),
+                first.clockwise(), first.bearing(), first.size(), first.kind(), bodies);
+    }
+
+    public static PortDayCycle compile(List<Identifier> pages, long seed, long nativeTicks) {
+        if (!validWriting(pages)) throw new IllegalArgumentException("An Age may have at most ten suns and ten moons");
+        if (pages.stream().filter(PortDayCycle::isController).count() <= 1)
+            return compileOne(pages, seed, nativeTicks, 0);
+        var bodies = new java.util.ArrayList<PortCelestialBody>();
+        PortDayCycle first = null;
+        int start = 0, ordinal = 0;
+        for (int i = 0; i < pages.size(); i++) if (isController(pages.get(i))) {
+            var cycle = compileOne(pages.subList(start, i + 1), seed, nativeTicks, ordinal++);
+            if (first == null) first = cycle;
+            // Prefix retains original page indices for seeded unnumbered colors.
+            int color = PortAgeColors.compile(pages.subList(0, i + 1), seed).celestial();
+            if (!cycle.bodies.isEmpty()) bodies.addAll(cycle.bodies);
+            else {
+                if (cycle.bodyMode != MOON) bodies.add(PortCelestialBody.of(cycle, SUN, color, false));
+                if (cycle.bodyMode != SUN) bodies.add(PortCelestialBody.of(cycle, MOON, color, cycle.bodyMode == PAIRED));
+            }
+            start = i + 1;
+        }
+        return new PortDayCycle(first.authored, first.period, first.stoppedTime, first.originTick,
+                first.phaseTick, first.clockwise, first.bearing, first.sunSize, first.bodyMode, bodies);
+    }
+
+    private static PortDayCycle compileOne(List<Identifier> pages, long seed, long nativeTicks, int ordinal) {
+        int controllerIndex = -1;
+        for (int i = 0; i < pages.size(); i++) if (isController(pages.get(i))) { controllerIndex = i; break; }
+        // Only preceding modifiers belong to this controller. In particular, a
+        // trailing dangling modifier must not rewrite the single-body fast path.
+        if (controllerIndex < 0) return NATIVE;
+        pages = pages.subList(0, controllerIndex + 1);
+        var controller = pages.getLast();
+        int mode = controller.getPath().equals("celestial/sun") ? SUN
+                : controller.getPath().equals("celestial/moon") ? MOON : PAIRED;
+        if (mode != PAIRED && !hasBodyModifiers(pages)) return randomUnmodified(seed, ordinal, nativeTicks, mode);
+        double period = 1;
+        Integer phase = null;
+        boolean clockwise = true;
+        int bearing = -1;
+        float size = 1F;
+        for (int i = 0; i < pages.size(); i++) {
+            Identifier page = pages.get(i);
+            int number = i > 0 ? PortAgeColors.number(pages.get(i - 1)) : -1;
+            if (isPhase(page)) {
+                int degrees = number >= 0 ? number * 15 % 360 : switch (page.getPath()) {
+                    case "phase/rising" -> 90;
+                    case "phase/zenith" -> 180;
+                    case "phase/setting" -> 270;
+                    default -> 0;
+                };
+                // Same conversion as 1.21.1 AgeDimensionService.applyInitialCelestialPhase:
+                // the written angle starts at Nadir, while native time zero is sunrise.
+                phase = (degrees * 24000 / 360 + 18000) % 24000;
+            } else if (isAngle(page)) {
+                bearing = number >= 0 ? number * 15 % 360 : switch (page.getPath()) {
+                    case "angle/east" -> 90;
+                    case "angle/south" -> 180;
+                    case "angle/west" -> 270;
+                    default -> 0;
+                };
+            } else if (isSize(page)) {
+                size = number >= 0 ? (float) (0.25D + number * (2.75D / 24D)) : switch (page.getPath()) {
+                    case "size/small" -> 0.5F;
+                    case "size/large" -> 2F;
+                    default -> 1F;
+                };
+            } else if (isDirection(page)) {
+                clockwise = page.getPath().equals("direction/clockwise");
+            } else if (isPeriod(page)) period = number >= 0 ? number * 0.08 : switch (page.getPath()) {
+                case "period/half" -> 0.5;
+                case "period/double" -> 2;
+                case "period/zero" -> 0;
+                default -> 1;
+            };
+        }
+        int stopped = period == 0 ? phase != null ? phase
+                : new Random(seed ^ 0x4441594359434C45L).nextInt(24000) : 0;
+        return new PortDayCycle(true, period, stopped, phase != null ? nativeTicks : 0,
+                phase == null ? 0 : phase, clockwise, bearing, size, mode);
+    }
+
+    private static boolean hasBodyModifiers(List<Identifier> pages) {
+        boolean color = false, controls = false;
+        for (var page : pages) {
+            if (isController(page)) return controls || color;
+            if (PortAgeColors.isColor(page)) color = true;
+            else if (PortSkyStyle.forPage(page) != null || page.equals(PortAgeColors.AMBIENT)) color = false;
+            if (isPeriod(page) || isPhase(page) || isDirection(page) || isAngle(page) || isSize(page)) controls = true;
+        }
+        return false;
+    }
+
+    private static PortDayCycle randomUnmodified(long seed, int ordinal, long nativeTicks, int mode) {
+        // Independent per-controller stream: unrelated terrain/sky/weather pages
+        // cannot reshuffle the bodies. Use root random-Age bounds, not native defaults.
+        var random = new Random(seed ^ 0x43454C4553544941L ^ (ordinal + 1L) * 0x9E3779B97F4A7C15L);
+        double period = random.nextInt(7) == 0 ? 0D : 0.2D + random.nextDouble() * 1.8D;
+        int phase = random.nextInt(24000), bearing = random.nextInt(360);
+        float size = 0.75F + random.nextFloat();
+        boolean clockwise = random.nextBoolean();
+        int color = randomColor(random);
+        var cycle = new PortDayCycle(true, period, period == 0 ? phase : 0, nativeTicks,
+                phase, clockwise, bearing, size, mode);
+        return new PortDayCycle(true, period, cycle.stoppedTime, nativeTicks, phase, clockwise, bearing, size,
+                mode, List.of(PortCelestialBody.of(cycle, mode, color, false)));
+    }
+
+    private static int randomColor(Random random) {
+        return PortAgeColors.randomColor(random, false);
+    }
+
+    public boolean singleBody() { return authored && (bodyMode == SUN || bodyMode == MOON); }
+    public boolean customLight() { return singleBody() || !bodies.isEmpty(); }
+
+    /** Linear authored orbit, as in 1.21.1 Body; zero degrees is Zenith. */
+    public float bodyAngle(long nativeTicks) {
+        return (float) (((time(nativeTicks) - 6000D) % 24000D) * (360D / 24000D));
+    }
+
+    public float bodyLight(long nativeTicks) {
+        if (bodyMode == NONE) return 0;
+        if (!bodies.isEmpty()) {
+            float sun = 0, moon = 0;
+            for (var body : bodies) {
+                if (body.kind() == SUN) sun += body.light(nativeTicks) * (1F - 0.85F * body.eclipse(bodies, nativeTicks));
+                else moon += body.light(nativeTicks);
+            }
+            return Math.min(1F, sun > 0 ? sun : moon);
+        }
+        float altitude = Math.max(0F, (float) Math.cos(Math.toRadians(bodyAngle(nativeTicks))));
+        return altitude * (bodyMode == MOON ? 0.18F : 1F);
+    }
+
+    public long ticks(long nativeTicks) {
+        if (!authored) return nativeTicks;
+        return (long) Math.floor(time(nativeTicks));
+    }
+
+    private double time(long nativeTicks) {
+        return !authored ? nativeTicks : period == 0 ? stoppedTime
+                : (clockwise ? 1 : -1) * ((double) nativeTicks - originTick) / period + phaseTick;
+    }
+
+    public static long nativeTicks(Level level) {
+        return level.clockManager().getInstance(level.registryAccess().lookupOrThrow(
+                net.minecraft.core.registries.Registries.WORLD_CLOCK).getOrThrow(WorldClocks.OVERWORLD)).totalTicks();
+    }
+
+    public static void updateClient(Map<Identifier, PortDayCycle> cycles) { clientCycles = Map.copyOf(cycles); }
+    public static PortDayCycle forLevel(Level level) {
+        if (level instanceof PortAgeLevel age) return age.dayCycle();
+        return level.isClientSide() ? clientCycles.getOrDefault(level.dimension().identifier(), NATIVE) : NATIVE;
+    }
+
+    /** Timelines keep this manager; profiles are read lazily after level construction/catalog sync. */
+    public static ClockManager timelines(Level level, ClockManager nativeManager) {
+        Map<Holder<WorldClock>, ClockInstance> wrappers = new HashMap<>();
+        return definition -> {
+            if (!definition.is(WorldClocks.OVERWORLD)) return nativeManager.getInstance(definition);
+            return wrappers.computeIfAbsent(definition, ignored -> new ClockInstance() {
+                private ClockInstance source() { return nativeManager.getInstance(definition); }
+                public long totalTicks() { return forLevel(level).ticks(source().totalTicks()); }
+                public float partialTick() {
+                    PortDayCycle cycle = forLevel(level);
+                    if (!cycle.authored) return source().partialTick();
+                    if (cycle.period == 0) return 0;
+                    double time = cycle.time(source().totalTicks());
+                    return (float) (time - Math.floor(time)
+                            + (cycle.clockwise ? 1 : -1) * source().partialTick() / cycle.period);
+                }
+                public float rate() {
+                    PortDayCycle cycle = forLevel(level);
+                    return !cycle.authored ? source().rate() : cycle.period == 0 ? 0
+                            : (float) ((cycle.clockwise ? 1 : -1) * source().rate() / cycle.period);
+                }
+                public boolean isPaused() { return source().isPaused() || forLevel(level).authored && forLevel(level).period == 0; }
+            });
+        };
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortDecayProviders.java

@@ -0,0 +1,202 @@
+package net.dnorberg.rivencraft.age;
+
+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.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+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 PortDecayProviders {
+    public static final TagKey<Block> PROTECTED = TagKey.create(Registries.BLOCK,
+            Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "decay_protected"));
+    private static final Map<Identifier, 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 PortDecayProviders() {}
+
+    public static void register() {
+        COLORS.keySet().forEach(id -> PortInstabilityRuntime.register(id, true, PortDecayProviders::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.level();
+        if (!PortInstabilityConfig.decayEnabled() || !PortInstabilityConfig.instabilityWorldMutation()
+                || !PortInstabilityRuntime.isAge(level)
+                || level.getChunkSource().getChunkNow(player.chunkPosition().x(), player.chunkPosition().z()) == null) return -1;
+        var age = PortInstabilityData.get(level.getServer()).age(level);
+        Identifier id = id("decay" + color.getSerializedName());
+        if (!PortInstabilityConfig.instabilityEnabled() || !age.enabled()
+                || !PortInstabilityConfig.instabilityProviderEnabled(id)) return -1;
+        int changed = 0;
+        for (int i = 0; i < Math.min(count, 32); i++) {
+            PortInstabilityRuntime.Budget budget = new PortInstabilityRuntime.Budget(1);
+            apply(new PortInstabilityRuntime.Context(level, age, List.of(player.chunkPosition()),
+                    level.getServer().getTickCount(), budget), id, 1);
+            changed += budget.applied();
+        }
+        return changed;
+    }
+
+    static void apply(PortInstabilityRuntime.Context context, Identifier id, int level) {
+        if (!PortInstabilityConfig.decayEnabled() || !PortInstabilityConfig.instabilityWorldMutation()
+                || !PortInstabilityRuntime.isAge(context.level())
+                || context.loadedChunks().isEmpty()) return;
+        DecayBlock.Color color = COLORS.get(id);
+        if (color == null) return;
+        PortDecaySavedData data = PortDecaySavedData.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(Rivencraft.DECAY.get()) || sourceState.getValue(DecayBlock.COLOR) != color) {
+            data.remove(color, source);
+            return;
+        }
+        for (int attempt = 0; attempt < PortInstabilityConfig.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(PortInstabilityRuntime.Context context, DecayBlock.Color color,
+                             PortDecaySavedData 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().getChunkNow(pos.getX() >> 4, pos.getZ() >> 4) != null
+                && chunks.contains(ChunkPos.containing(pos));
+    }
+
+    static boolean isSpawnProtected(PortInstabilityData.Age age, BlockPos pos) {
+        BlockPos spawn = age.spawn().orElse(null);
+        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 (!PortInstabilityRuntime.isAge(level)
+                || !level.isInWorldBounds(pos) || level.getChunkSource().getChunkNow(pos.getX() >> 4, pos.getZ() >> 4) == null
+                || 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(Rivencraft.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() != Rivencraft.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(Rivencraft.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(PortInstabilityRuntime.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 net.neoforged.neoforge.event.level.block.BreakBlockEvent(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 = Rivencraft.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;
+        }
+        context.budget().recordApplied();
+        return true;
+    }
+
+    private static Identifier id(String path) {
+        return Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortDecaySavedData.java

@@ -0,0 +1,44 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.minecraft.core.BlockPos;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+/** Persisted per-Age frontier and attempt sequence, bounded to 1,024 positions per color. */
+public final class PortDecaySavedData extends SavedData {
+    private static final int MAX_FRONTIER_PER_COLOR = 1024;
+    private static final Codec<PortDecaySavedData> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            net.minecraft.util.ExtraCodecs.NON_NEGATIVE_LONG.optionalFieldOf("attempts", 0L).forGetter(data -> data.attempts),
+            Codec.unboundedMap(StringRepresentable.fromEnum(DecayBlock.Color::values),
+                    BlockPos.CODEC.listOf(0, MAX_FRONTIER_PER_COLOR)).fieldOf("frontiers").forGetter(data -> data.frontiers)
+    ).apply(instance, PortDecaySavedData::new));
+    private static final SavedDataType<PortDecaySavedData> TYPE = new SavedDataType<>(
+            Identifier.fromNamespaceAndPath("rivencraft", "decay"), () -> new PortDecaySavedData(0, Map.of()), CODEC);
+    private final EnumMap<DecayBlock.Color, List<BlockPos>> frontiers = new EnumMap<>(DecayBlock.Color.class);
+    private long attempts;
+    private PortDecaySavedData(long attempts, Map<DecayBlock.Color, List<BlockPos>> positions) {
+        this.attempts = attempts;
+        for (var color : DecayBlock.Color.values()) frontiers.put(color,
+                new ArrayList<>(positions.getOrDefault(color, List.of()).stream().distinct().map(BlockPos::immutable).toList()));
+    }
+    public static PortDecaySavedData get(ServerLevel level) { return level.getDataStorage().computeIfAbsent(TYPE); }
+    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) {
+        var frontier = frontiers.get(color);
+        if (frontier.contains(pos)) return;
+        if (frontier.size() >= MAX_FRONTIER_PER_COLOR) frontier.removeFirst();
+        frontier.add(pos.immutable()); setDirty();
+    }
+    public void remove(DecayBlock.Color color, BlockPos pos) { if (frontiers.get(color).remove(pos)) setDirty(); }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortDenseOres.java

@@ -0,0 +1,90 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderSet;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.tags.TagKey;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ChunkPos;
+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.AbstractOreFeature;
+import net.minecraft.world.level.levelgen.placement.FeaturePlacer;
+import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import net.neoforged.neoforge.common.Tags;
+
+/** Replays each eligible biome ore placement once per page, matching Rivencraft 1.21.1. */
+public final class PortDenseOres {
+    public static final TagKey<PlacedFeature> EXTRA_ORES = TagKey.create(Registries.PLACED_FEATURE,
+            Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "dense_ores"));
+
+    private PortDenseOres() {}
+
+    public static boolean hasOres(Holder<Biome> biome) {
+        return oreFeatures(biome).anyMatch(PortDenseOres::isOre);
+    }
+
+    /** Modern ore features carry their targets directly rather than an OreConfiguration. */
+    public static boolean isOre(Holder<PlacedFeature> holder) {
+        if (holder.is(EXTRA_ORES)) return true;
+        if (!(holder.value().feature().value() instanceof AbstractOreFeature ore)) return false;
+        return ore.targetStates().stream().anyMatch(target -> isOreBlock(target.state()));
+    }
+
+    private static boolean isOreBlock(BlockState state) {
+        if (state.is(Tags.BlockItems.ORES.block())) return true;
+        String path = BuiltInRegistries.BLOCK.getKey(state.getBlock()).getPath();
+        return path.endsWith("_ore") || path.contains("_ore_");
+    }
+
+    private static java.util.stream.Stream<Holder<PlacedFeature>> oreFeatures(Holder<Biome> biome) {
+        return biome.value().getGenerationSettings().features().stream().flatMap(HolderSet::stream);
+    }
+
+    public static void place(WorldGenLevel level, ChunkAccess chunk, ChunkGenerator generator,
+                             long ageSeed, int count) {
+        if (count == 0) return;
+        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());
+        // Collect once per chunk, not once per repeated page. Stable registry-ID
+        // order and per-occurrence seeds retain the 1.21.1 placement sequence.
+        Map<Identifier, PlacedFeature> ores = new TreeMap<>();
+        for (Holder<Biome> biome : biomes) {
+            oreFeatures(biome).filter(PortDenseOres::isOre).forEach(feature ->
+                    feature.unwrapKey().ifPresent(key -> ores.putIfAbsent(key.identifier(), feature.value())));
+        }
+        BlockPos origin = new BlockPos(chunk.getPos().getMinBlockX(), level.getMinY(),
+                chunk.getPos().getMinBlockZ());
+        FeaturePlacer placer = new FeaturePlacer(level, generator);
+        for (int occurrence = 0; occurrence < count; occurrence++) {
+            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);
+                placer.placeWithBiomeCheck(entry.getValue(), RandomSource.create(seed), origin);
+            }
+        }
+    }
+
+    private static long mix(long value) {
+        value = (value ^ value >>> 30) * 0xBF58476D1CE4E5B9L;
+        value = (value ^ value >>> 27) * 0x94D049BB133111EBL;
+        return value ^ value >>> 31;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortDroppedBookProbe.java

@@ -0,0 +1,81 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.entity.DroppedBookEntity;
+import net.dnorberg.rivencraft.item.LinkBookTarget;
+import net.dnorberg.rivencraft.item.PortHandheldTravel;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.storage.TagValueInput;
+import net.minecraft.world.level.storage.TagValueOutput;
+import net.minecraft.util.ProblemReporter;
+import net.minecraft.world.phys.AABB;
+import net.neoforged.neoforge.common.util.FakePlayerFactory;
+
+/** Disposable-world checks for book ownership and the new entity save format. */
+final class PortDroppedBookProbe {
+    private PortDroppedBookProbe() {}
+
+    static void create(ServerLevel level) {
+        PortAgeTravel.findLanding(level);
+        var player = FakePlayerFactory.get(level, new com.mojang.authlib.GameProfile(
+                UUID.fromString("4db5c544-0a0c-421d-a128-c520bda64642"), "RivenBookProbe"));
+        player.setPos(0.5, 64, 0.5);
+        try {
+            for (var hand : InteractionHand.values()) {
+                ItemStack book = new ItemStack(hand == InteractionHand.MAIN_HAND
+                        ? Rivencraft.LINKING_BOOK.get() : Rivencraft.DESCRIPTIVE_BOOK.get());
+                book.set(DataComponents.CUSTOM_NAME, Component.literal("Dropped fixture " + hand));
+                book.set(Rivencraft.LINK_BOOK_TARGET.get(), new LinkBookTarget(
+                        Identifier.fromNamespaceAndPath("minecraft", "overworld"), 12.25, 80.5, -42.75, 135, -20));
+                player.setItemInHand(hand, book);
+                String failure = PortHandheldTravel.travel(player, hand, book, () -> "expected failure");
+                if (!"expected failure".equals(failure) || player.getItemInHand(hand) != book)
+                    throw new IllegalStateException("Failed travel consumed the book");
+                try {
+                    PortHandheldTravel.travel(player, hand, book, () -> { throw new IllegalStateException("fixture"); });
+                    throw new AssertionError("Fixture exception was swallowed");
+                } catch (IllegalStateException expected) {
+                    if (!"fixture".equals(expected.getMessage()) || player.getItemInHand(hand) != book) throw expected;
+                }
+                java.util.function.Consumer<net.neoforged.neoforge.event.entity.EntityJoinLevelEvent> cancel = event -> {
+                    if (event.getLevel() == level && event.getEntity() instanceof DroppedBookEntity) event.setCanceled(true);
+                };
+                net.neoforged.neoforge.common.NeoForge.EVENT_BUS.addListener(cancel);
+                try {
+                    failure = PortHandheldTravel.travel(player, hand, book, () -> null);
+                    if (failure != null || player.getItemInHand(hand) != book)
+                        throw new IllegalStateException("Rejected dropped entity consumed the book");
+                } finally { net.neoforged.neoforge.common.NeoForge.EVENT_BUS.unregister(cancel); }
+                failure = PortHandheldTravel.travel(player, hand, book, () -> null);
+                if (failure != null || !player.getItemInHand(hand).isEmpty())
+                    throw new IllegalStateException("Successful travel retained the active book");
+            }
+        } finally { player.getInventory().clearContent(); }
+        verify(level);
+    }
+
+    static void verify(ServerLevel level) {
+        var books = level.getEntitiesOfClass(DroppedBookEntity.class, new AABB(-2, 60, -2, 3, 68, 3));
+        if (books.size() != 2) throw new IllegalStateException("Expected two dropped books, found " + books.size());
+        for (var entity : books) {
+            var output = TagValueOutput.createWithContext(ProblemReporter.DISCARDING, level.registryAccess());
+            entity.saveWithoutId(output);
+            var copy = new DroppedBookEntity(Rivencraft.DROPPED_BOOK.get(), level);
+            copy.load(TagValueInput.create(ProblemReporter.DISCARDING, level.registryAccess(), output.buildResult()));
+            if (!ItemStack.isSameItemSameComponents(copy.getItem(), entity.getItem())
+                    || copy.getAge() != -32768 || copy.getItem().getCount() != 1)
+                throw new IllegalStateException("Dropped book persistence regression");
+            var copied = TagValueOutput.createWithContext(ProblemReporter.DISCARDING, level.registryAccess());
+            copy.saveWithoutId(copied);
+            if (copied.buildResult().getIntOr("BookDecayTicks", -1)
+                    != output.buildResult().getIntOr("BookDecayTicks", -2))
+                throw new IllegalStateException("Dropped book decay counter was not preserved");
+        }
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortEnvironmentSelection.java

@@ -0,0 +1,28 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import net.minecraft.resources.Identifier;
+
+/** Seed-completes missing environment controllers once, before an Age is saved. */
+public record PortEnvironmentSelection(PortWeatherMode weather, PortLighting lighting, PortSkyStyle sky) {
+    public static PortEnvironmentSelection resolve(List<Identifier> pages, long seed, PortAgeTerrain terrain) {
+        PortLighting lighting = pages.stream().map(PortLighting::forPage).filter(java.util.Objects::nonNull)
+                .findFirst().orElseGet(() -> rankedDefault(new Random(seed ^ 0x4C49474854494E47L), PortLighting.values()));
+        PortWeatherMode weather = terrain == PortAgeTerrain.CAVE ? PortWeatherMode.OFF
+                : pages.stream().map(PortWeatherMode::forPage).filter(java.util.Objects::nonNull)
+                        .findFirst().orElseGet(() -> rankedDefault(new Random(seed ^ 0x574541544845525FL), PortWeatherMode.values()));
+        return new PortEnvironmentSelection(weather, lighting, PortSkyStyle.resolve(pages, seed));
+    }
+
+    private static <T> T rankedDefault(Random random, T[] choices) {
+        // LegacyRankChoice: the first (Normal) option is rank 1, the rest rank 2.
+        // Its rank-1 weight is the complete rare group plus one. Derive this
+        // from the supported pool, rather than selecting unported weather.
+        int[] weights = new int[choices.length];
+        Arrays.fill(weights, 1);
+        weights[0] = choices.length;
+        return PortRandomAgeSelection.weighted(random, List.of(choices), weights);
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortEnvironmentalProviders.java

@@ -0,0 +1,178 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Random;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.entity.EntityTypeTest;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.AABB;
+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;
+
+/** Active Legacy burning and the 1.21.1 test-enabled erosion policy. */
+public final class PortEnvironmentalProviders {
+    public static final Identifier BURNING = Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "burning");
+    public static final Identifier EROSION = Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "erosion");
+    private static final Direction[] FLUID_SIDES = {
+            Direction.UP, Direction.NORTH, Direction.SOUTH, Direction.EAST, Direction.WEST
+    };
+    private PortEnvironmentalProviders() {}
+    public static void register() {
+        PortInstabilityRuntime.register(BURNING, false, (context, id, level) -> {
+            if (PortInstabilityRuntime.isAge(context.level()) && !context.loadedChunks().isEmpty()) scorch(context, level);
+        });
+        PortInstabilityRuntime.register(EROSION, true, (context, id, level) -> {
+            if (PortInstabilityRuntime.isAge(context.level()) && !context.loadedChunks().isEmpty()) erode(context);
+        });
+    }
+    public static boolean isEnvironmental(Identifier id) { return id.equals(BURNING) || id.equals(EROSION); }
+    static void tickPlanned(ServerLevel level, PortInstabilityData.Age age, long tick,
+                            List<PortInstabilityPlan.ProviderLevel> providers) {
+        var cards = providers.stream().filter(card -> isEnvironmental(card.id())).toList();
+        boolean erosion = PortInstabilityConfig.erosionEnabled() && PortInstabilityRuntime.effectiveScore(level)
+                >= InstabilityProviderCatalog.Deck.DESTRUCTIVE.entryCost();
+        if (cards.isEmpty() && !erosion) return;
+        var chunks = PortHazardProviders.loadedChunksNearPlayers(level, PortInstabilityConfig.hazardsMaxChunks());
+        if (chunks.isEmpty()) return;
+        for (var card : cards) {
+            int budget = card.id().equals(BURNING) ? PortInstabilityConfig.scorchMaxTargets() : 1;
+            PortInstabilityRuntime.invoke(new PortInstabilityRuntime.Context(level, age, chunks, tick,
+                    new PortInstabilityRuntime.Budget(budget)), card.id(), card.level());
+        }
+        if (erosion && cards.stream().noneMatch(card -> card.id().equals(EROSION)))
+            PortInstabilityRuntime.invoke(new PortInstabilityRuntime.Context(level, age, chunks, tick,
+                    new PortInstabilityRuntime.Budget(1)), EROSION, 1);
+    }
+    /** Skips random burning selection or looks at one erosion target, preserving policy. */
+    public static int pulseForTesting(ServerPlayer player, String effect) {
+        ServerLevel level = player.level();
+        if (!PortInstabilityRuntime.isAge(level)) return -1;
+        var age = PortInstabilityData.get(level.getServer()).age(level);
+        Identifier id = effect.equals("burning") ? BURNING : EROSION;
+        if (!PortInstabilityConfig.instabilityEnabled() || !age.enabled()
+                || !PortInstabilityConfig.instabilityProviderEnabled(id)) return 0;
+        var chunks = PortHazardProviders.loadedChunksNearPlayers(level, 16);
+        if (chunks.isEmpty()) return 0;
+        var context = new PortInstabilityRuntime.Context(level, age, chunks,
+                level.getServer().getTickCount(), new PortInstabilityRuntime.Budget(1));
+        if (effect.equals("burning")) {
+            if (!PortInstabilityConfig.scorchEnabled() || !PortInstabilityConfig.scorchPlayers()
+                    || !eligibleScorch(context, player)) return 0;
+            if (player.isInWaterOrRain()) return -2;
+            player.igniteForSeconds(4);
+            return 1;
+        }
+        if (!effect.equals("erosion") || !PortInstabilityConfig.erosionEnabled() || !PortHazardProviders.canMutate(level)
+                || PortInstabilityRuntime.effectiveScore(level) < InstabilityProviderCatalog.Deck.DESTRUCTIVE.entryCost()
+                || !(player.pick(6.0, 0.0F, false) instanceof BlockHitResult hit)
+                || hit.getType() != net.minecraft.world.phys.HitResult.Type.BLOCK) return 0;
+        return erodeAt(context, hit.getBlockPos()) ? 1 : 0;
+    }
+
+    private static void scorch(PortInstabilityRuntime.Context context, int effectiveLevel) {
+        if (!PortInstabilityConfig.scorchEnabled() || PortInstabilityConfig.scorchMaxTargets() == 0) return;
+        ServerLevel level = context.level();
+        Random random = new Random(context.age().seed() ^ PortHazardSavedData.get(level).nextAttempt()
+                * 0x9E3779B97F4A7C15L ^ BURNING.hashCode());
+        int start = random.nextInt(context.loadedChunks().size());
+        int affected = 0;
+        for (int offset = 0; offset < Math.min(8, context.loadedChunks().size()); offset++) {
+            ChunkPos chunk = context.loadedChunks().get((start + offset) % context.loadedChunks().size());
+            AABB bounds = new AABB(chunk.getMinBlockX(), level.getMinY(), chunk.getMinBlockZ(),
+                    chunk.getMaxBlockX() + 1, level.getMaxY(), chunk.getMaxBlockZ() + 1);
+            List<LivingEntity> candidates = new ArrayList<>();
+            level.getEntities(EntityTypeTest.forClass(LivingEntity.class), bounds,
+                    entity -> eligibleScorch(context, entity), candidates, 8);
+            candidates.sort(Comparator.comparing(Entity::getUUID));
+            for (LivingEntity entity : candidates) {
+                if (affected >= PortInstabilityConfig.scorchMaxTargets() || context.budget().remaining() == 0) return;
+                // Legacy sampled each chunk each tick with a 1/10 gate. With 20 ticks/pass this
+                // gives at least one opportunity for nearly every inspected loaded chunk.
+                if (random.nextDouble() >= PortHazardProviders.legacyChance(1,
+                        PortInstabilityConfig.instabilityCooldown(), 1, 10)) continue;
+                if (!context.budget().claim()) return;
+                entity.igniteForSeconds(Math.min(12, 4 * effectiveLevel));
+                context.budget().recordApplied();
+                affected++;
+                break;
+            }
+        }
+    }
+
+    private static boolean eligibleScorch(PortInstabilityRuntime.Context context, LivingEntity entity) {
+        if (!entity.isAlive() || entity.isRemoved() || entity.level() != context.level()
+                || !context.level().canSeeSky(entity.blockPosition())
+                || PortDecayProviders.isSpawnProtected(context.age(), entity.blockPosition())) return false;
+        if (entity instanceof Player player) return PortInstabilityConfig.scorchPlayers()
+                && !player.isCreative() && !player.isSpectator();
+        return true;
+    }
+
+    private static void erode(PortInstabilityRuntime.Context context) {
+        if (!PortInstabilityConfig.erosionEnabled() || !PortHazardProviders.canMutate(context.level())) return;
+        ServerLevel level = context.level();
+        Random random = new Random(context.age().seed() ^ PortHazardSavedData.get(level).nextAttempt()
+                * 0xC2B2AE3D27D4EB4FL ^ EROSION.hashCode());
+        for (int attempt = 0; attempt < 8; attempt++) {
+            ChunkPos chunk = context.loadedChunks().get(random.nextInt(context.loadedChunks().size()));
+            int x = chunk.getMinBlockX() + random.nextInt(16);
+            int z = chunk.getMinBlockZ() + random.nextInt(16);
+            int y = level.getMinY() + 1 + random.nextInt(level.getHeight() - 2);
+            if (erodeAt(context, new BlockPos(x, y, z))) return;
+        }
+    }
+
+    static boolean erodeAt(PortInstabilityRuntime.Context context, BlockPos pos) {
+        ServerLevel level = context.level();
+        if (!PortDecayProviders.isLoadedTarget(level, context.loadedChunks(), pos)
+                || PortDecayProviders.isSpawnProtected(context.age(), pos)) return false;
+        BlockState prior = level.getBlockState(pos);
+        if (!PortDecayProviders.canReplace(level, pos, prior, DecayBlock.Color.BLUE)) return false;
+        for (Direction direction : FLUID_SIDES) {
+            BlockPos neighbor = pos.relative(direction);
+            if (!PortDecayProviders.isLoadedTarget(level, context.loadedChunks(), neighbor)) continue;
+            var fluid = level.getFluidState(neighbor);
+            if (fluid.isSource() && replaceFluid(context, pos, prior, fluid.createLegacyBlock())) return true;
+        }
+        return false;
+    }
+
+    private static boolean replaceFluid(PortInstabilityRuntime.Context context, BlockPos pos,
+            BlockState prior, BlockState fluidBlock) {
+        ServerLevel level = context.level();
+        var actor = FakePlayerFactory.getMinecraft(level);
+        actor.setPos(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        if (!prior.isAir()) {
+            var breaking = new net.neoforged.neoforge.event.level.block.BreakBlockEvent(level, pos, prior, actor);
+            NeoForge.EVENT_BUS.post(breaking);
+            if (breaking.isCanceled()) return false;
+        }
+        if (level.getBlockState(pos) != prior || !context.budget().claim()) return false;
+        var snapshot = BlockSnapshot.create(level.dimension(), level, pos);
+        if (!level.setBlock(pos, fluidBlock, 3)) return false;
+        var placing = new BlockEvent.EntityPlaceEvent(snapshot, prior, actor);
+        NeoForge.EVENT_BUS.post(placing);
+        if (placing.isCanceled()) {
+            snapshot.restore();
+            return false;
+        }
+        context.budget().recordApplied();
+        return true;
+    }
+
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortFeatureChunkGenerator.java

@@ -0,0 +1,304 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.PortRegistryPages;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.tags.TagKey;
+import net.minecraft.tags.BiomeTags;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.LevelHeightAccessor;
+import net.minecraft.world.level.NoiseColumn;
+import net.minecraft.world.level.StructureManager;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.BiomeManager;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.levelgen.RandomState;
+import net.minecraft.world.level.levelgen.blending.Blender;
+import net.minecraft.world.level.levelgen.densityfunction.SamplerContext;
+import net.minecraft.world.level.levelgen.blockpredicates.BlockPredicate;
+import net.minecraft.world.level.levelgen.feature.BlockBlobFeature;
+import net.minecraft.world.level.levelgen.feature.LakeFeature;
+import net.minecraft.world.level.levelgen.feature.stateproviders.BlockStateProvider;
+import net.minecraft.world.level.levelgen.placement.BiomeFilter;
+import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import net.minecraft.world.level.levelgen.placement.RarityFilter;
+import net.minecraft.world.level.levelgen.structure.StructureSet;
+import net.minecraft.world.level.levelgen.structure.Structure;
+import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager;
+import com.mojang.datafixers.util.Pair;
+import net.minecraft.core.HolderSet;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.Block;
+
+/** Delegates terrain generation and applies frozen Age-scoped features. */
+public final class PortFeatureChunkGenerator extends ChunkGenerator {
+    private static final ResourceKey<PlacedFeature> FOREST_ROCK = ResourceKey.create(
+            Registries.PLACED_FEATURE, Identifier.withDefaultNamespace("forest_rock"));
+    private static final ResourceKey<PlacedFeature> DUNGEONS = ResourceKey.create(
+            Registries.PLACED_FEATURE, Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "dungeons"));
+    private static final TagKey<Block> ROCK_GROUND = TagKey.create(
+            Registries.BLOCK, Identifier.withDefaultNamespace("forest_rock_can_place_on"));
+    public static final MapCodec<PortFeatureChunkGenerator> CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(
+            ChunkGenerator.CODEC.fieldOf("base").forGetter(generator -> generator.base),
+            PortRockPlan.CODEC.optionalFieldOf("rocks").forGetter(generator -> Optional.ofNullable(generator.rocks)),
+            PortVegetationPlan.CODEC.optionalFieldOf("vegetation")
+                    .forGetter(generator -> Optional.ofNullable(generator.vegetation)),
+            com.mojang.serialization.Codec.intRange(0, 32).optionalFieldOf("dungeons", 0)
+                    .forGetter(generator -> generator.dungeons),
+            PortLakePlan.CODEC.optionalFieldOf("lakes")
+                    .forGetter(generator -> Optional.ofNullable(generator.lakes)),
+            PortTerrainFeaturePlan.CODEC.optionalFieldOf("terrain_features")
+                    .forGetter(generator -> Optional.ofNullable(generator.terrainFeatures)),
+            com.mojang.serialization.Codec.LONG.fieldOf("age_seed").forGetter(generator -> generator.ageSeed),
+            com.mojang.serialization.Codec.BOOL.optionalFieldOf("libraries", false).forGetter(generator -> generator.libraries),
+            Identifier.CODEC.listOf().optionalFieldOf("library_symbols", List.of()).forGetter(generator -> generator.librarySymbols)
+    ).apply(instance, (base, rocks, vegetation, dungeons, lakes, terrainFeatures, seed, libraries, symbols) ->
+            new PortFeatureChunkGenerator(base, rocks.orElse(null), vegetation.orElse(null),
+                    dungeons, lakes.orElse(null), terrainFeatures.orElse(null), seed, libraries, symbols)));
+
+    private final ChunkGenerator base;
+    private final PortRockPlan rocks;
+    private final PortVegetationPlan vegetation;
+    private final int dungeons;
+    private final PortLakePlan lakes;
+    private final PortTerrainFeaturePlan terrainFeatures;
+    private final long ageSeed;
+    private final boolean libraries;
+    private final List<Identifier> librarySymbols;
+
+    public PortFeatureChunkGenerator(ChunkGenerator base, PortRockPlan rocks,
+                                     PortVegetationPlan vegetation, int dungeons, PortLakePlan lakes,
+                                     PortTerrainFeaturePlan terrainFeatures, long ageSeed) {
+        this(base, rocks, vegetation, dungeons, lakes, terrainFeatures, ageSeed, false, List.of());
+    }
+
+    public PortFeatureChunkGenerator(ChunkGenerator base, PortRockPlan rocks,
+                                     PortVegetationPlan vegetation, int dungeons, PortLakePlan lakes,
+                                     PortTerrainFeaturePlan terrainFeatures, long ageSeed,
+                                     boolean libraries, List<Identifier> librarySymbols) {
+        super(base.getBiomeSource(), base::getBiomeGenerationSettings);
+        this.base = base;
+        this.rocks = rocks;
+        this.vegetation = vegetation;
+        this.dungeons = dungeons;
+        this.lakes = lakes;
+        this.terrainFeatures = terrainFeatures;
+        this.ageSeed = ageSeed;
+        this.libraries = libraries;
+        this.librarySymbols = List.copyOf(librarySymbols);
+    }
+
+    public ChunkGenerator base() { return base; }
+    public PortRockPlan rocks() { return rocks; }
+    public PortVegetationPlan vegetation() { return vegetation; }
+    public int dungeons() { return dungeons; }
+    public PortLakePlan lakes() { return lakes; }
+    public PortTerrainFeaturePlan terrainFeatures() { return terrainFeatures; }
+
+    @Override protected MapCodec<? extends ChunkGenerator> codec() { return CODEC; }
+    @Override public void validate() { base.validate(); }
+    @Override public ChunkPos getOrigin(RandomState random) { return base.getOrigin(random); }
+    @Override public java.util.Optional<Identifier> getTypeNameForDataFixer() { return base.getTypeNameForDataFixer(); }
+    @Override public CompletableFuture<ChunkAccess> createBiomes(RandomState random, Blender blender,
+                                                                  StructureManager structures, ChunkAccess chunk) {
+        return base.createBiomes(random, blender, structures, chunk);
+    }
+    @Override public ChunkGeneratorStructureState createState(HolderLookup<StructureSet> sets,
+                                                               RandomState random, long seed) {
+        if (controlsStructures()) {
+            var lookup = PortStructurePages.filtered(sets, terrainFeatures.structures(), getBiomeSource());
+            var planning = PortStructurePages.planningBiomes(getBiomeSource(), sets, terrainFeatures.structures());
+            if (base instanceof PortFlatChunkGenerator || base instanceof net.minecraft.world.level.levelgen.FlatLevelSource)
+                return ChunkGeneratorStructureState.createForFlat(random, seed, getOrigin(random), planning,
+                        lookup.listElements().map(holder -> (Holder<StructureSet>) holder));
+            return ChunkGeneratorStructureState.createForNormal(random, seed, getOrigin(random), planning, lookup);
+        }
+        return base.createState(sets, random, seed);
+    }
+
+    private boolean controlsStructures() {
+        return terrainFeatures != null && (terrainFeatures.structureControl() || !terrainFeatures.structures().isEmpty());
+    }
+    @Override public void createStructures(RegistryAccess registries, ChunkGeneratorStructureState state,
+                                           StructureManager structures, ChunkAccess chunk,
+                                           StructureTemplateManager templates, ResourceKey<Level> dimension) {
+        if (controlsStructures()) super.createStructures(registries, state, structures, chunk, templates, dimension);
+        else base.createStructures(registries, state, structures, chunk, templates, dimension);
+    }
+    @Override public void createReferences(WorldGenLevel level, StructureManager structures, ChunkAccess chunk) {
+        base.createReferences(level, structures, chunk);
+    }
+    @Override public Pair<BlockPos, Holder<Structure>> findNearestMapStructure(ServerLevel level,
+            HolderSet<Structure> targets, BlockPos origin, int radius, boolean skipKnown) {
+        return base.findNearestMapStructure(level, targets, origin, radius, skipKnown);
+    }
+    @Override public void spawnOriginalMobs(WorldGenRegion level) { base.spawnOriginalMobs(level); }
+    @Override public int getSpawnHeight(LevelHeightAccessor height) { return base.getSpawnHeight(height); }
+    @Override public int getGenDepth() { return base.getGenDepth(); }
+    @Override public int getSeaLevel() { return base.getSeaLevel(); }
+    @Override public int getMinY() { return base.getMinY(); }
+    @Override public CompletableFuture<ChunkAccess> buildTerrain(ChunkAccess chunk, Blender blender,
+            RandomState random, StructureManager structures, BiomeManager biomes,
+            WorldGenRegion carverBiomeRegion, Set<Holder<Biome>> possibleBiomes) {
+        CompletableFuture<ChunkAccess> built = base.buildTerrain(
+                chunk, blender, random, structures, biomes, carverBiomeRegion, possibleBiomes);
+        if (terrainFeatures == null || !terrainFeatures.skylands() && terrainFeatures.choices().isEmpty()) return built;
+        return built.thenApply(result -> {
+            // Match 1.21.1: filter the base terrain once, then add the authored
+            // solid volumes, irrespective of the Skylands page's written position.
+            if (terrainFeatures.skylands()) PortSkylandsFeature.filter(result, ageSeed);
+            java.util.Map<Identifier, Integer> occurrences = new java.util.HashMap<>();
+            for (PortTerrainFeaturePlan.Choice choice : terrainFeatures.choices()) {
+                if (PortTerrainFeaturePlan.isSurface(choice.page())) continue;
+                int occurrence = occurrences.merge(choice.page(), 1, Integer::sum) - 1;
+                long featureSeed = ageSeed ^ (long) occurrence * 0x9E3779B97F4A7C15L;
+                BlockState material = BuiltInRegistries.BLOCK.getValue(choice.material()).defaultBlockState();
+                if (choice.page().equals(PortTerrainFeaturePlan.FLOATING_ISLANDS))
+                    PortFloatingIslandFeature.generate(result, featureSeed, material);
+                else if (choice.page().equals(PortTerrainFeaturePlan.TENDRILS))
+                    PortTendrilFeature.generate(result, featureSeed, material);
+                else if (choice.page().equals(PortTerrainFeaturePlan.SPHERES))
+                    PortSpheresFeature.generate(result, featureSeed, material);
+                else throw new IllegalStateException("Unsupported terrain feature: " + choice.page());
+            }
+            return result;
+        });
+    }
+    @Override public int getBaseHeight(int x, int z, Heightmap.Types type,
+                                       LevelHeightAccessor height, RandomState random) {
+        return base.getBaseHeight(x, z, type, height, random);
+    }
+    @Override public NoiseColumn getBaseColumn(int x, int z, LevelHeightAccessor height, RandomState random) {
+        return base.getBaseColumn(x, z, height, random);
+    }
+    @Override public void addDebugScreenInfo(List<String> info, RandomState random,
+                                              BlockPos pos, SamplerContext context) {
+        base.addDebugScreenInfo(info, random, pos, context);
+    }
+    @Override public void refreshFeaturesPerStep() {
+        base.refreshFeaturesPerStep();
+        super.refreshFeaturesPerStep();
+    }
+
+    @Override public void applyBiomeDecoration(WorldGenLevel level, ChunkAccess chunk,
+                                                StructureManager structures) {
+        base.applyBiomeDecoration(level, chunk, structures);
+        if (terrainFeatures != null) {
+            PortDenseOres.place(level, chunk, this, ageSeed, terrainFeatures.denseOres());
+            int spikeOccurrence = 0;
+            int obeliskOccurrence = 0;
+            int crystalOccurrence = 0;
+            for (PortTerrainFeaturePlan.Choice choice : terrainFeatures.choices()) {
+                if (!PortTerrainFeaturePlan.isSurface(choice.page())) continue;
+                BlockState material = BuiltInRegistries.BLOCK.getValue(choice.material()).defaultBlockState();
+                if (choice.page().equals(PortTerrainFeaturePlan.SPIKES))
+                    PortSpikesFeature.generate(level, chunk, ageSeed, material, spikeOccurrence++);
+                else if (choice.page().equals(PortTerrainFeaturePlan.OBELISKS))
+                    PortObelisksFeature.generate(level, chunk, ageSeed, material, obeliskOccurrence++);
+                else if (choice.page().equals(PortTerrainFeaturePlan.CRYSTAL_FORMATIONS))
+                    PortCrystalFormationsFeature.generate(level, chunk, ageSeed, crystalOccurrence++);
+                else throw new IllegalStateException("Unsupported surface feature: " + choice.page());
+            }
+        }
+        ChunkPos chunkPos = chunk.getPos();
+        long chunkSeed = ageSeed ^ (long) chunkPos.x() * 341873128712L
+                ^ (long) chunkPos.z() * 132897987541L;
+        BlockPos origin = new BlockPos(chunkPos.getMinBlockX(), level.getMinY(), chunkPos.getMinBlockZ());
+        if (rocks != null) {
+            PlacedFeature vanilla = level.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE)
+                    .getOrThrow(FOREST_ROCK).value();
+            var placement = vanilla.placement().stream()
+                    .filter(modifier -> !(modifier instanceof BiomeFilter)).toList();
+            for (int occurrence = 0; occurrence < rocks.materials().size(); occurrence++) {
+                RandomSource random = RandomSource.create(chunkSeed
+                        ^ (long) occurrence * 0xD1B54A32D192ED03L);
+                BlockState material = BuiltInRegistries.BLOCK.getValue(
+                        rocks.materials().get(occurrence)).defaultBlockState();
+                PlacedFeature authored = new PlacedFeature(Holder.direct(new BlockBlobFeature(
+                        material, BlockPredicate.matchesTag(ROCK_GROUND))), placement);
+                authored.place(level, this, random, origin);
+            }
+        }
+        if (dungeons > 0) {
+            PlacedFeature authored = level.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE)
+                    .getOrThrow(DUNGEONS).value();
+            for (int occurrence = 0; occurrence < dungeons; occurrence++) {
+                RandomSource random = RandomSource.create(chunkSeed
+                        ^ 0x44554E47454F4E53L ^ (long) occurrence * 0xD1B54A32D192ED03L);
+                authored.place(level, this, random, origin);
+            }
+        }
+        if (lakes != null) {
+            var registry = level.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE);
+            java.util.Map<PortLakePlan.Choice, Integer> occurrences = new java.util.HashMap<>();
+            for (PortLakePlan.Choice choice : lakes.choices()) {
+                PlacedFeature vanilla = registry.getOrThrow(ResourceKey.create(
+                        Registries.PLACED_FEATURE, PortLakePlan.placedFeature(choice.page()))).value();
+                if (!(vanilla.feature().value() instanceof LakeFeature lake))
+                    throw new IllegalStateException("Lake placement no longer references a LakeFeature: " + choice.page());
+                BlockState fluid = BuiltInRegistries.BLOCK.getValue(choice.fluid()).defaultBlockState();
+                LakeFeature feature = new LakeFeature(BlockStateProvider.holderOf(fluid), lake.barrier(),
+                        lake.canPlaceFeature(), lake.canReplaceWithAirOrFluid(), lake.canReplaceWithBarrier());
+                PlacedFeature authored = new PlacedFeature(Holder.direct(feature), vanilla.placement().stream()
+                        .filter(modifier -> !(modifier instanceof BiomeFilter))
+                        .map(modifier -> !PortLakePlan.isDeep(choice.page()) && modifier instanceof RarityFilter
+                                ? RarityFilter.onAverageOnceEvery(12) : modifier)
+                        .toList());
+                int occurrence = occurrences.merge(choice, 1, Integer::sum) - 1;
+                RandomSource random = RandomSource.create(chunkSeed
+                        ^ (long) choice.hashCode() * 0x9E3779B97F4A7C15L
+                        ^ (long) occurrence * 0xD1B54A32D192ED03L);
+                authored.place(level, this, random, origin);
+            }
+        }
+        if (vegetation != null) {
+            int surface = chunk.getHeight(Heightmap.Types.WORLD_SURFACE_WG, 8, 8);
+            Holder<Biome> biome = level.getBiome(new BlockPos(
+                    chunkPos.getMinBlockX() + 8, surface, chunkPos.getMinBlockZ() + 8));
+            boolean surfaceBiome = !biome.is(BiomeTags.IS_END) && !PortRegistryPages.isCaveBiome(biome);
+            var registry = level.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE);
+            List<BlockPos> mushroomHosts = null;
+            for (int occurrence = 0; occurrence < vegetation.pages().size(); occurrence++) {
+                Identifier page = vegetation.pages().get(occurrence);
+                RandomSource random = RandomSource.create(chunkSeed
+                        ^ (long) page.hashCode() * 0x9E3779B97F4A7C15L
+                        ^ (long) occurrence * 0xD1B54A32D192ED03L);
+                if (page.equals(PortVegetationPlan.SHELF_MUSHROOMS)) {
+                    if (mushroomHosts == null) mushroomHosts = PortShelfMushrooms.findHosts(chunk);
+                    PortShelfMushrooms.decorate(level, chunk, mushroomHosts, random);
+                    continue;
+                }
+                if (!surfaceBiome) continue;
+                Identifier placedId = PortVegetationPlan.placedFeature(page);
+                PlacedFeature vanilla = registry.getOrThrow(
+                        ResourceKey.create(Registries.PLACED_FEATURE, placedId)).value();
+                PlacedFeature authored = new PlacedFeature(vanilla.feature(), vanilla.placement().stream()
+                        .filter(modifier -> !(modifier instanceof BiomeFilter)).toList());
+                authored.place(level, this, random, origin);
+                if (PortVegetationPlan.addsLogs(page)) mushroomHosts = null;
+            }
+        }
+        if (libraries) PortLibraryFeature.generate(level, chunk, ageSeed, librarySymbols);
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortFlatChunkGenerator.java

@@ -0,0 +1,142 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.HolderSet;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.LevelHeightAccessor;
+import net.minecraft.world.level.NoiseColumn;
+import net.minecraft.world.level.StructureManager;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.BiomeGenerationSettings;
+import net.minecraft.world.level.biome.BiomeManager;
+import net.minecraft.world.level.biome.BiomeSource;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
+import net.minecraft.world.level.levelgen.GenerationStep;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.levelgen.RandomState;
+import net.minecraft.world.level.levelgen.blending.Blender;
+import net.minecraft.world.level.levelgen.densityfunction.SamplerContext;
+import net.minecraft.world.level.levelgen.flat.FlatLevelGeneratorSettings;
+import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import net.minecraft.world.level.levelgen.structure.StructureSet;
+import net.neoforged.neoforge.common.util.MemoizedFunction;
+import org.jspecify.annotations.Nullable;
+
+/** Flat layers with the authored biome distribution used by 1.21.1 Ages. */
+public final class PortFlatChunkGenerator extends ChunkGenerator {
+    public static final MapCodec<PortFlatChunkGenerator> CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(
+            BiomeSource.CODEC.fieldOf("biome_source").forGetter(generator -> generator.biomeSource),
+            FlatLevelGeneratorSettings.CODEC.fieldOf("settings").forGetter(PortFlatChunkGenerator::settings)
+    ).apply(instance, PortFlatChunkGenerator::new));
+
+    private final FlatLevelGeneratorSettings settings;
+    private final MemoizedFunction<Holder<Biome>, BiomeGenerationSettings> generationSettingsGetter;
+
+    public PortFlatChunkGenerator(BiomeSource biomeSource, FlatLevelGeneratorSettings settings) {
+        super(biomeSource, this.generationSettingsGetter = MemoizedFunction.of(
+                biome -> generationSettings(settings, biome)));
+        this.settings = settings;
+    }
+
+    public FlatLevelGeneratorSettings settings() {
+        return settings;
+    }
+
+    private static BiomeGenerationSettings generationSettings(FlatLevelGeneratorSettings settings, Holder<Biome> biome) {
+        // Void biomes still control climate, but must not place terrain features.
+        if (settings.getLayersInfo().isEmpty()) return BiomeGenerationSettings.EMPTY;
+        if (biome.equals(settings.getBiome())) return settings.adjustGenerationSettings(biome);
+        BiomeGenerationSettings.PlainBuilder builder = new BiomeGenerationSettings.PlainBuilder();
+        List<HolderSet<PlacedFeature>> features = biome.value().getGenerationSettings().features();
+        for (int step = 0; step < features.size(); step++) {
+            if (step == GenerationStep.Decoration.UNDERGROUND_STRUCTURES.ordinal()
+                    || step == GenerationStep.Decoration.SURFACE_STRUCTURES.ordinal()) continue;
+            for (Holder<PlacedFeature> feature : features.get(step)) builder.addFeature(step, feature);
+        }
+        return builder.build();
+    }
+
+    @Override
+    protected MapCodec<? extends ChunkGenerator> codec() {
+        return CODEC;
+    }
+
+    @Override
+    public ChunkGeneratorStructureState createState(HolderLookup<StructureSet> structures,
+                                                    RandomState random, long seed) {
+        Stream<Holder<StructureSet>> entries = settings.structureOverrides()
+                .map(HolderSet::stream)
+                .orElseGet(() -> structures.listElements().map(holder -> (Holder<StructureSet>) holder));
+        return ChunkGeneratorStructureState.createForFlat(random, seed, getOrigin(random), biomeSource, entries);
+    }
+
+    @Override
+    public int getSpawnHeight(LevelHeightAccessor height) {
+        return height.getMinY() + Math.min(height.getHeight(), settings.getLayers().size());
+    }
+
+    @Override
+    public CompletableFuture<ChunkAccess> buildTerrain(ChunkAccess chunk, Blender blender,
+            RandomState random, StructureManager structures, BiomeManager biomes,
+            @Nullable WorldGenRegion carverBiomeRegion, Set<Holder<Biome>> possibleBiomes) {
+        List<BlockState> layers = settings.getLayers();
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        Heightmap floor = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
+        Heightmap surface = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
+        for (int layer = 0; layer < Math.min(chunk.getHeight(), layers.size()); layer++) {
+            BlockState state = layers.get(layer);
+            if (state == null) continue;
+            int y = chunk.getMinY() + layer;
+            for (int x = 0; x < 16; x++) for (int z = 0; z < 16; z++) {
+                chunk.setBlockState(pos.set(x, y, z), state);
+                floor.update(x, y, z, state);
+                surface.update(x, y, z, state);
+            }
+        }
+        return CompletableFuture.completedFuture(chunk);
+    }
+
+    @Override
+    public int getBaseHeight(int x, int z, Heightmap.Types type,
+                             LevelHeightAccessor height, RandomState random) {
+        List<BlockState> layers = settings.getLayers();
+        for (int layer = Math.min(layers.size() - 1, height.getHeight() - 1); layer >= 0; layer--) {
+            BlockState state = layers.get(layer);
+            if (state != null && type.isOpaque().test(state)) return height.getMinY() + layer + 1;
+        }
+        return height.getMinY();
+    }
+
+    @Override
+    public NoiseColumn getBaseColumn(int x, int z, LevelHeightAccessor height, RandomState random) {
+        return new NoiseColumn(height.getMinY(), settings.getLayers().stream().limit(height.getHeight())
+                .map(state -> state == null ? Blocks.AIR.defaultBlockState() : state)
+                .toArray(BlockState[]::new));
+    }
+
+    @Override public void addDebugScreenInfo(List<String> info, RandomState random,
+                                             BlockPos pos, SamplerContext context) { }
+    @Override public void spawnOriginalMobs(WorldGenRegion level) { }
+    @Override public int getMinY() { return 0; }
+    @Override public int getGenDepth() { return 384; }
+    @Override public int getSeaLevel() { return -63; }
+
+    @Override
+    public void refreshFeaturesPerStep() {
+        super.refreshFeaturesPerStep();
+        generationSettingsGetter.clear();
+        settings.updateLayers();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortFloatingIslandFeature.java

@@ -0,0 +1,83 @@
+package net.dnorberg.rivencraft.age;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.QuartPos;
+import net.minecraft.tags.BiomeTags;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.dnorberg.rivencraft.writing.PortRegistryPages;
+
+/** 1.21.1 floating-island shape adapted to the 26.3 chunk terrain stage. */
+final class PortFloatingIslandFeature {
+    private static final long SALT = 0x464C4F4154494E47L;
+    private static final int SOURCE_RANGE = 3;
+    private static final int CHANCE = 128;
+
+    private PortFloatingIslandFeature() {}
+
+    static void generate(ChunkAccess chunk, long ageSeed, BlockState material) {
+        var target = chunk.getPos();
+        for (int sourceX = target.x() - SOURCE_RANGE; sourceX <= target.x() + SOURCE_RANGE; sourceX++) {
+            for (int sourceZ = target.z() - SOURCE_RANGE; sourceZ <= target.z() + SOURCE_RANGE; sourceZ++) {
+                RandomSource random = RandomSource.create(mix(ageSeed ^ SALT
+                        ^ (long) sourceX * 341873128712L ^ (long) sourceZ * 132897987541L));
+                if (random.nextInt(CHANCE) != 0) continue;
+                int centerX = sourceX * 16 + random.nextInt(16);
+                int centerZ = sourceZ * 16 + random.nextInt(16);
+                int centerY = Math.min(chunk.getMaxY() - 30, 168 + random.nextInt(48));
+                if (centerY < chunk.getMinY() + 24) continue;
+                int radiusX = 24 + random.nextInt(18);
+                int radiusZ = 24 + random.nextInt(18);
+                fill(chunk, ageSeed, material, centerX, centerY, centerZ, radiusX, radiusZ);
+            }
+        }
+    }
+
+    private static void fill(ChunkAccess chunk, long ageSeed, BlockState material,
+                             int centerX, int centerY, int centerZ, int radiusX, int radiusZ) {
+        int originX = chunk.getPos().getMinBlockX();
+        int originZ = chunk.getPos().getMinBlockZ();
+        Heightmap surface = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
+        Heightmap floor = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        for (int localX = 0; localX < 16; localX++) {
+            int worldX = originX + localX;
+            double dx = (worldX - centerX) / (double) radiusX;
+            for (int localZ = 0; localZ < 16; localZ++) {
+                int worldZ = originZ + localZ;
+                double dz = (worldZ - centerZ) / (double) radiusZ;
+                double distance = dx * dx + dz * dz;
+                if (distance >= 1.0) continue;
+                long detail = mix(ageSeed ^ (long) centerX * 341873128712L
+                        ^ (long) centerZ * 132897987541L ^ (long) worldX * 42317861L
+                        ^ (long) worldZ * 374761393L);
+                int top = centerY + (int) Math.round(3 * (1 - distance)) + Math.floorMod(detail, 3) - 1;
+                int depth = Math.max(1, (int) Math.round(3 + 17 * Math.pow(1 - distance, 1.5)));
+                // Biomes are already populated by createBiomes in 26.3, so
+                // sampling this chunk preserves its authored biome distribution.
+                var biome = chunk.getNoiseBiome(QuartPos.fromBlock(worldX), QuartPos.fromBlock(top),
+                        QuartPos.fromBlock(worldZ));
+                BlockState soil = biome.is(BiomeTags.IS_END) || PortRegistryPages.isCaveBiome(biome)
+                        ? material : Blocks.DIRT.defaultBlockState();
+                BlockState cap = soil == material ? material : Blocks.GRASS_BLOCK.defaultBlockState();
+                for (int y = Math.max(top - depth, chunk.getMinY()); y <= top; y++) {
+                    pos.set(worldX, y, worldZ);
+                    if (!chunk.getBlockState(pos).isAir()) continue;
+                    BlockState state = y == top ? cap : y >= top - 3 ? soil : material;
+                    chunk.setBlockState(pos, state);
+                    surface.update(localX, y, localZ, state);
+                    floor.update(localX, y, localZ, state);
+                }
+            }
+        }
+    }
+
+    private static long mix(long value) {
+        value = (value ^ value >>> 30) * 0xBF58476D1CE4E5B9L;
+        value = (value ^ value >>> 27) * 0x94D049BB133111EBL;
+        return value ^ value >>> 31;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortHazardProviders.java

@@ -0,0 +1,356 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Random;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Predicate;
+import net.dnorberg.rivencraft.Rivencraft;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityTypes;
+import net.minecraft.world.entity.LightningBolt;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.Explosion;
+import net.minecraft.world.level.ExplosionDamageCalculator;
+import net.minecraft.world.level.gamerules.GameRules;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.phys.AABB;
+import net.neoforged.neoforge.common.NeoForge;
+import net.neoforged.neoforge.common.util.FakePlayerFactory;
+import net.neoforged.neoforge.event.level.BlockEvent;
+
+/** Legacy hazard cards, with one loaded-chunk event and explicit damage budgets. */
+public final class PortHazardProviders {
+    private static final Identifier LIGHTNING = id("lightning");
+    private static final Identifier EXPLOSIONS = id("explosions");
+
+    private PortHazardProviders() {}
+
+    public static void register() {
+        // Visuals and entity damage remain available when block mutation is disabled.
+        PortInstabilityRuntime.register(LIGHTNING, false, PortHazardProviders::apply);
+        PortInstabilityRuntime.register(EXPLOSIONS, false, PortHazardProviders::apply);
+    }
+
+    static boolean isHazard(Identifier id) {
+        return LIGHTNING.equals(id) || EXPLOSIONS.equals(id);
+    }
+
+    /** Roll every selected hazard card each scheduler pass, independently of other providers. */
+    static void tickPlanned(ServerLevel level, PortInstabilityData.Age age, long tick,
+                            List<PortInstabilityPlan.ProviderLevel> providers) {
+        if (!PortInstabilityConfig.hazardsEnabled()) return;
+        List<PortInstabilityPlan.ProviderLevel> hazards = providers.stream()
+                .filter(provider -> isHazard(provider.id())).toList();
+        if (hazards.isEmpty()) return;
+        List<ChunkPos> chunks = loadedChunksNearPlayers(level, PortInstabilityConfig.hazardsMaxChunks());
+        if (chunks.isEmpty()) return;
+        for (PortInstabilityPlan.ProviderLevel hazard : hazards) {
+            var context = new PortInstabilityRuntime.Context(level, age, chunks, tick,
+                    new PortInstabilityRuntime.Budget(1));
+            PortInstabilityRuntime.invoke(context, hazard.id(), hazard.level());
+        }
+    }
+
+    static List<ChunkPos> loadedChunksNearPlayers(ServerLevel level, int maximum) {
+        List<ChunkPos> players = level.players().stream()
+                .sorted(Comparator.comparing(Entity::getUUID))
+                .map(ServerPlayer::chunkPosition).toList();
+        return candidateChunks(players, maximum,
+                chunk -> level.getChunkSource().getChunkNow(chunk.x(), chunk.z()) != null);
+    }
+
+    /** Pure candidate selection; the caller's predicate must only report already-loaded chunks. */
+    static List<ChunkPos> candidateChunks(List<ChunkPos> players, int maximum,
+                                           Predicate<ChunkPos> loaded) {
+        if (maximum <= 0) return List.of();
+        Set<ChunkPos> chunks = new LinkedHashSet<>();
+        for (int radius = 0; radius <= 4; radius++) {
+            for (int dx = -radius; dx <= radius; dx++) {
+                for (int dz = -radius; dz <= radius; dz++) {
+                    if (Math.max(Math.abs(dx), Math.abs(dz)) != radius) continue;
+                    for (ChunkPos center : players) {
+                        int x = center.x() + dx;
+                        int z = center.z() + dz;
+                        ChunkPos candidate = new ChunkPos(x, z);
+                        if (loaded.test(candidate)) chunks.add(candidate);
+                        if (chunks.size() >= maximum) return List.copyOf(chunks);
+                    }
+                }
+            }
+        }
+        return List.copyOf(chunks);
+    }
+
+    /** Operator-only test pulse; skips the random roll, not Age, cooldown, or safety checks. */
+    public static int pulseForTesting(ServerPlayer player, boolean lightning) {
+        return pulseForTesting(player.level(), player.blockPosition(), lightning);
+    }
+
+    public static int pulseForTesting(ServerLevel level, BlockPos origin, boolean lightning) {
+        if (!PortInstabilityConfig.hazardsEnabled()
+                || !PortInstabilityRuntime.isAge(level)) return -1;
+        var age = PortInstabilityData.get(level.getServer()).age(level);
+        if (!PortInstabilityConfig.instabilityEnabled() || !age.enabled()
+                || !PortInstabilityConfig.instabilityProviderEnabled(lightning ? LIGHTNING : EXPLOSIONS)) return -1;
+        PortHazardSavedData data = PortHazardSavedData.get(level);
+        if (!data.ready(lightning, level.getGameTime(), PortInstabilityConfig.hazardsMinInterval())) return 0;
+        ChunkPos center = ChunkPos.containing(origin);
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                ChunkPos chunk = new ChunkPos(center.x() + dx, center.z() + dz);
+                if (level.getChunkSource().getChunkNow(chunk.x(), chunk.z()) == null) continue;
+                int x = chunk.getMinBlockX() + 8;
+                int z = chunk.getMinBlockZ() + 8;
+                int y = lightning ? level.getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)
+                        : origin.getY();
+                BlockPos pos = new BlockPos(x, y, z);
+                var context = new PortInstabilityRuntime.Context(level, age, List.of(chunk),
+                        level.getServer().getTickCount(), new PortInstabilityRuntime.Budget(1));
+                if (!safeTarget(context, pos, 8)) continue;
+                data.nextAttempt();
+                data.record(lightning, level.getGameTime());
+                return (lightning ? strike(level, age, chunk, pos) : explode(level, age, chunk, pos)) ? 1 : 0;
+            }
+        }
+        return 0;
+    }
+
+    static void apply(PortInstabilityRuntime.Context context, Identifier id, int effectiveLevel) {
+        ServerLevel level = context.level();
+        if (!PortInstabilityConfig.hazardsEnabled() || context.loadedChunks().isEmpty()
+                || !PortInstabilityRuntime.isAge(level)) return;
+        boolean lightning = id.equals(LIGHTNING);
+        if (!lightning && !id.equals(EXPLOSIONS)) return;
+        PortHazardSavedData data = PortHazardSavedData.get(level);
+        long gameTime = level.getGameTime();
+        if (!data.ready(lightning, gameTime, PortInstabilityConfig.hazardsMinInterval())) return;
+        Random random = new Random(context.age().seed() ^ data.nextAttempt() * 0x9E3779B97F4A7C15L
+                ^ id.hashCode());
+        int legacyDenominator = lightning ? level.isRaining() && level.isThundering() ? 5000 : 100000 : 1000;
+        // Legacy rolled once per chunk per tick; the shared scheduler visits this Age every >=20 ticks.
+        double chance = legacyChance(context.loadedChunks().size(), PortInstabilityConfig.instabilityCooldown(),
+                effectiveLevel, legacyDenominator);
+        if (random.nextDouble() >= chance) return;
+        ChunkPos chunk = context.loadedChunks().get(random.nextInt(context.loadedChunks().size()));
+        int margin = lightning ? 2 : 6;
+        int x = chunk.getMinBlockX() + margin + random.nextInt(16 - margin * 2);
+        int z = chunk.getMinBlockZ() + margin + random.nextInt(16 - margin * 2);
+        int y = lightning ? level.getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)
+                : level.getMinY() + 1 + random.nextInt(level.getHeight() - 2);
+        BlockPos pos = new BlockPos(x, y, z);
+        if (!safeTarget(context, pos, 8) || !context.budget().claim()) return;
+        data.record(lightning, gameTime); // persist before dispatch so a restart cannot replay the event
+        if (lightning ? strike(level, context.age(), chunk, pos) : explode(level, context.age(), chunk, pos))
+            context.budget().recordApplied();
+    }
+
+    static double legacyChance(int loadedChunks, int intervalTicks, int copies, int denominator) {
+        if (loadedChunks <= 0 || intervalTicks <= 0 || copies <= 0 || denominator <= 0) return 0;
+        return 1.0 - Math.pow(1.0 - 1.0 / denominator, (double) loadedChunks * intervalTicks * copies);
+    }
+
+    static boolean safeTarget(PortInstabilityRuntime.Context context, BlockPos pos, int spawnMargin) {
+        if (!PortDecayProviders.isLoadedTarget(context.level(), context.loadedChunks(), pos)) return false;
+        BlockPos spawn = context.age().spawn().orElse(null);
+        return spawn == null || Math.abs(pos.getX() - spawn.getX()) > spawnMargin
+                || Math.abs(pos.getZ() - spawn.getZ()) > spawnMargin;
+    }
+
+    private static boolean strike(ServerLevel level, PortInstabilityData.Age age, ChunkPos chunk, BlockPos pos) {
+        AABB bounds = new AABB(pos).inflate(2);
+        if (!level.getEntitiesOfClass(LightningBolt.class, bounds).isEmpty()) return false;
+        LightningBolt bolt = EntityTypes.LIGHTNING_BOLT.create(level, net.minecraft.world.entity.EntitySpawnReason.TRIGGERED);
+        if (bolt == null) return false;
+        bolt.setPos(pos.getX() + 0.5, pos.getY(), pos.getZ() + 0.5);
+        bolt.setVisualOnly(true); // vanilla bolt damage/fire bypasses our explicit budgets
+        if (!level.addFreshEntity(bolt)) return false;
+        List<LivingEntity> targets = level.getEntitiesOfClass(LivingEntity.class, bounds,
+                entity -> entity.isAlive() && entity.level() == level && eligibleEntity(entity));
+        targets.sort(Comparator.comparing(Entity::getUUID));
+        int count = 0;
+        for (LivingEntity target : targets) {
+            if (count++ >= PortInstabilityConfig.hazardsMaxEntities()) break;
+            if (PortInstabilityConfig.hazardsMaxDamage() > 0)
+                target.hurtServer(level, level.damageSources().lightningBolt(), Math.min(5, PortInstabilityConfig.hazardsMaxDamage()));
+        }
+        // Legacy lightning started fires. Keep it separately gated by block policy and game rule.
+        if (canMutate(level) && PortInstabilityConfig.hazardsFire()
+                && level.canSpreadFireAround(pos)
+                && !PortDecayProviders.isSpawnProtected(age, pos)
+                && PortDecayProviders.isLoadedTarget(level, List.of(chunk), pos)) ignite(level, pos);
+        return true;
+    }
+
+    private static boolean explode(ServerLevel level, PortInstabilityData.Age age, ChunkPos chunk, BlockPos pos) {
+        return explodeBounded(level, age, chunk, pos, PortInstabilityConfig.hazardsBlockDamage(),
+                PortInstabilityConfig.hazardsPlayerDamage(), PortInstabilityConfig.hazardsFire(),
+                PortInstabilityConfig.hazardsMaxBlocks(), PortInstabilityConfig.hazardsMaxEntities(),
+                PortInstabilityConfig.hazardsMaxDamage(), PortInstabilityConfig.hazardsExplosionRadius());
+    }
+
+    /** Shared blast guard for meteor impacts; each effect supplies its own damage policy. */
+    static boolean explodeBounded(ServerLevel level, PortInstabilityData.Age age, ChunkPos chunk, BlockPos pos,
+            boolean blockDamage, boolean playerDamage, boolean ignite, int maxBlocks, int maxEntities,
+            int maxDamage, int radius) {
+        boolean grief = destructiveBlocksAllowed(PortInstabilityConfig.instabilityWorldMutation(),
+                level.getGameRules().get(GameRules.MOB_GRIEFING), blockDamage, maxBlocks);
+        boolean fire = grief && ignite
+                && level.canSpreadFireAround(pos);
+        BoundedExplosion calculator = new BoundedExplosion(level, age, chunk, grief,
+                playerDamage, maxBlocks, maxEntities, maxDamage);
+        level.explode(null, null, calculator,
+                pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5,
+                radius, false,
+                grief ? Level.ExplosionInteraction.BLOCK : Level.ExplosionInteraction.NONE);
+        if (fire) {
+            int ignited = 0;
+            for (BlockPos affected : calculator.approved) {
+                if (ignited >= 4) break;
+                if (level.canSpreadFireAround(affected) && !PortDecayProviders.isSpawnProtected(age, affected)
+                        && ignite(level, affected)) ignited++;
+            }
+        }
+        return calculator.started;
+    }
+
+    private static boolean ignite(ServerLevel level, BlockPos pos) {
+        if (!level.getBlockState(pos).isAir() || !Blocks.FIRE.defaultBlockState().canSurvive(level, pos))
+            return false;
+        var actor = FakePlayerFactory.getMinecraft(level);
+        actor.setPos(pos.getX() + 0.5, pos.getY(), pos.getZ() + 0.5);
+        var snapshot = net.neoforged.neoforge.common.util.BlockSnapshot.create(level.dimension(), level, pos);
+        BlockState prior = level.getBlockState(pos);
+        if (!level.setBlock(pos, Blocks.FIRE.defaultBlockState(), 3)) return false;
+        var place = new BlockEvent.EntityPlaceEvent(snapshot, prior, actor);
+        NeoForge.EVENT_BUS.post(place);
+        if (place.isCanceled()) {
+            snapshot.restore();
+            return false;
+        }
+        return true;
+    }
+
+    static boolean canMutate(ServerLevel level) {
+        return PortInstabilityConfig.instabilityWorldMutation()
+                && level.getGameRules().get(GameRules.MOB_GRIEFING);
+    }
+
+    static boolean destructiveBlocksAllowed(boolean worldMutation, boolean mobGriefing,
+                                            boolean blockDamage, int maxBlocks) {
+        return worldMutation && mobGriefing && blockDamage && maxBlocks > 0;
+    }
+
+    static boolean protectedBlock(ServerLevel level, PortInstabilityData.Age age, BlockPos pos, BlockState state) {
+        return state.isAir() || state.hasBlockEntity() || state.is(Blocks.TNT)
+                || state.is(PortDecayProviders.PROTECTED) || state.is(BlockTags.PORTALS)
+                || PortDecayProviders.isSpawnProtected(age, pos)
+                || state.getDestroySpeed(level, pos) < 0
+                || BuiltInRegistries.BLOCK.getKey(state.getBlock()).getNamespace().equals(Rivencraft.MOD_ID);
+    }
+
+    private static boolean eligibleEntity(Entity entity) {
+        return eligibleEntity(entity, PortInstabilityConfig.hazardsPlayerDamage());
+    }
+
+    private static boolean eligibleEntity(Entity entity, boolean playerDamage) {
+        return !(entity instanceof Player player) || playerDamage
+                && !player.isCreative() && !player.isSpectator();
+    }
+
+    private static Identifier id(String path) {
+        return Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private static final class BoundedExplosion extends ExplosionDamageCalculator {
+        private final ServerLevel level;
+        private final PortInstabilityData.Age age;
+        private final ChunkPos chunk;
+        private final boolean grief;
+        private final boolean playerDamage;
+        private final int maxBlocks;
+        private final int maxEntities;
+        private final int maxDamage;
+        private final Set<BlockPos> approved = new LinkedHashSet<>();
+        private final Set<UUID> damagedEntities = new HashSet<>();
+        private int damaged;
+        private boolean started;
+
+        private BoundedExplosion(ServerLevel level, PortInstabilityData.Age age, ChunkPos chunk, boolean grief,
+                boolean playerDamage, int maxBlocks, int maxEntities, int maxDamage) {
+            this.level = level;
+            this.age = age;
+            this.chunk = chunk;
+            this.grief = grief;
+            this.playerDamage = playerDamage;
+            this.maxBlocks = maxBlocks;
+            this.maxEntities = maxEntities;
+            this.maxDamage = maxDamage;
+        }
+
+        @Override
+        public Optional<Float> getBlockExplosionResistance(Explosion explosion, BlockGetter reader,
+                BlockPos pos, BlockState state, FluidState fluid) {
+            started = true;
+            if (!inLoadedChunk(pos)) return Optional.of(Float.MAX_VALUE);
+            return super.getBlockExplosionResistance(explosion, reader, pos, state, fluid);
+        }
+
+        @Override
+        public boolean shouldBlockExplode(Explosion explosion, BlockGetter reader, BlockPos pos,
+                BlockState state, float power) {
+            if (!grief || !inLoadedChunk(pos) || protectedBlock(level, age, pos, state)) return false;
+            if (approved.contains(pos)) return true;
+            if (approved.size() >= maxBlocks) return false;
+            var actor = FakePlayerFactory.getMinecraft(level);
+            actor.setPos(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+            var event = new net.neoforged.neoforge.event.level.block.BreakBlockEvent(level, pos, state, actor);
+            NeoForge.EVENT_BUS.post(event);
+            if (event.isCanceled()) return false;
+            approved.add(pos.immutable());
+            return true;
+        }
+
+        @Override
+        public boolean shouldDamageEntity(Explosion explosion, Entity entity) {
+            if (damaged >= maxEntities || !eligibleEntity(entity, playerDamage)
+                    || maxDamage == 0) return false;
+            damaged++;
+            damagedEntities.add(entity.getUUID());
+            return true;
+        }
+
+        @Override
+        public float getEntityDamageAmount(Explosion explosion, Entity entity, float exposure) {
+            return Math.min(super.getEntityDamageAmount(explosion, entity, exposure), maxDamage);
+        }
+
+        @Override
+        public float getKnockbackMultiplier(Entity entity) {
+            return damagedEntities.contains(entity.getUUID()) ? 1.0F : 0.0F;
+        }
+
+        private boolean inLoadedChunk(BlockPos pos) {
+            return level.isInWorldBounds(pos) && ChunkPos.containing(pos).equals(chunk)
+                    && level.getChunkSource().getChunkNow(chunk.x(), chunk.z()) != null;
+        }
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortHazardSavedData.java

@@ -0,0 +1,34 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+/** Per-Age random sequence and event cooldowns survive unload and restart. */
+public final class PortHazardSavedData extends SavedData {
+    private static final Codec<PortHazardSavedData> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            net.minecraft.util.ExtraCodecs.NON_NEGATIVE_LONG.optionalFieldOf("attempts", 0L).forGetter(data -> data.attempts),
+            Codec.LONG.optionalFieldOf("last_lightning", Long.MIN_VALUE).forGetter(data -> data.lastLightning),
+            Codec.LONG.optionalFieldOf("last_explosion", Long.MIN_VALUE).forGetter(data -> data.lastExplosion),
+            Codec.LONG.optionalFieldOf("last_meteor", Long.MIN_VALUE).forGetter(data -> data.lastMeteor)
+    ).apply(instance, PortHazardSavedData::new));
+    private static final SavedDataType<PortHazardSavedData> TYPE = new SavedDataType<>(
+            Identifier.fromNamespaceAndPath("rivencraft", "hazards"),
+            () -> new PortHazardSavedData(0, Long.MIN_VALUE, Long.MIN_VALUE, Long.MIN_VALUE), CODEC);
+    private long attempts, lastLightning, lastExplosion, lastMeteor;
+    private PortHazardSavedData(long attempts, long lightning, long explosion, long meteor) {
+        this.attempts = attempts; lastLightning = lightning; lastExplosion = explosion; lastMeteor = meteor;
+    }
+    public static PortHazardSavedData get(ServerLevel level) { return level.getDataStorage().computeIfAbsent(TYPE); }
+    public long nextAttempt() { setDirty(); return attempts++; }
+    public boolean ready(boolean lightning, long time, int interval) {
+        long last = lightning ? lastLightning : lastExplosion;
+        return last == Long.MIN_VALUE || time < last || time - last >= interval;
+    }
+    public void record(boolean lightning, long time) { if (lightning) lastLightning = time; else lastExplosion = time; setDirty(); }
+    public boolean meteorReady(long time, int interval) { return lastMeteor == Long.MIN_VALUE || time < lastMeteor || time - lastMeteor >= interval; }
+    public void recordMeteor(long time) { lastMeteor = time; setDirty(); }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortInstabilityCommands.java

@@ -0,0 +1,172 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.brigadier.arguments.BoolArgumentType;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.commands.Commands;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.Identifier;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.neoforge.event.RegisterCommandsEvent;
+
+/** Scores and test overrides are deliberately operator-only, never book tooltip data. */
+@EventBusSubscriber(modid = Rivencraft.MOD_ID)
+public final class PortInstabilityCommands {
+    private PortInstabilityCommands() {}
+    @SubscribeEvent public static void register(RegisterCommandsEvent event) {
+        event.getDispatcher().register(Commands.literal("rivencraft_port")
+                .requires(Commands.hasPermission(Commands.LEVEL_ADMINS))
+                .then(Commands.literal("instability")
+                        .then(Commands.literal("status").executes(context -> {
+                            var source = context.getSource(); var level = requireAge(source);
+                            var age = PortInstabilityData.get(source.getServer()).age(level);
+                            source.sendSuccess(() -> Component.literal("Age " + level.dimension().identifier()
+                                    + ": frozen score=" + age.score() + ", enabled=" + age.enabled()
+                                    + ", session test score=" + PortInstabilityRuntime.testScore(level)
+                                    + ", protected spawn=" + age.spawn().map(BlockPos::toShortString).orElse("not recorded; re-enter this Age")), false);
+                            source.sendSuccess(() -> Component.literal("  live block score=" + PortBlockInstability.score(level)
+                                    + "; effective score=" + PortInstabilityRuntime.effectiveScore(level)
+                                    + "; difficulty=" + PortInstabilityConfig.instabilityDifficulty()
+                                    + "; samples Age=" + PortBlockInstability.sampledChunks(level) + "/" + PortBlockProfileSavedData.MIN_AGE_SAMPLES
+                                    + ", Overworld=" + PortBlockInstability.sampledChunks(source.getServer().overworld()) + "/" + PortBlockProfileSavedData.MIN_BASELINE_SAMPLES
+                                    + "; profiling=" + PortInstabilityData.get(source.getServer()).supportsProfiling(level)), false);
+                            for (var cost : age.contributions()) source.sendSuccess(() -> Component.literal(
+                                    "  " + cost.reason() + " page=" + cost.page() + " +" + cost.points()), false);
+                            source.sendSuccess(() -> Component.literal("  erosion testing policy (not a saved card): "
+                                    + PortInstabilityRuntime.providerStatus(level, PortEnvironmentalProviders.EROSION)
+                                    + "; current score=" + PortInstabilityRuntime.effectiveScore(level)), false);
+                            for (var provider : PortInstabilityRuntime.plan(level).providers())
+                                source.sendSuccess(() -> Component.literal("  " + provider.id() + " level=" + provider.level()
+                                        + " [" + PortInstabilityRuntime.providerStatus(level, provider.id()) + "]"), false);
+                            return 1;
+                        }))
+                        .then(Commands.literal("enabled").then(Commands.argument("enabled", BoolArgumentType.bool())
+                                .executes(context -> {
+                                    var level = requireAge(context.getSource());
+                                    boolean enabled = BoolArgumentType.getBool(context, "enabled");
+                                    PortInstabilityData.get(level.getServer()).enabled(level, enabled);
+                                    if (!enabled) PortStatusEffectProviders.clearAge(level);
+                                    context.getSource().sendSuccess(() -> Component.literal("Age instability enabled=" + enabled
+                                            + "; saved score and provider selection unchanged"), false);
+                                    return 1;
+                                })))
+                        .then(Commands.literal("test_score").then(Commands.argument("score", IntegerArgumentType.integer(0, 1_000_000))
+                                .executes(context -> {
+                                    var level = requireAge(context.getSource());
+                                    PortInstabilityRuntime.testScore(level, IntegerArgumentType.getInteger(context, "score"));
+                                    PortStatusEffectProviders.clearAge(level);
+                                    context.getSource().sendSuccess(() -> Component.literal("Session-only score override set; frozen score unchanged. Restart or clear_test_score removes it."), false);
+                                    return 1;
+                                })))
+                        .then(Commands.literal("clear_test_score").executes(context -> {
+                            var level = requireAge(context.getSource()); PortInstabilityRuntime.testScore(level, null);
+                            PortStatusEffectProviders.clearAge(level);
+                            context.getSource().sendSuccess(() -> Component.literal("Cleared test override; restored live effective provider selection"), false); return 1;
+                        }))
+                        .then(Commands.literal("decay").then(Commands.argument("color", StringArgumentType.word())
+                                .suggests((context, builder) -> {
+                                    for (var color : net.dnorberg.rivencraft.block.DecayBlock.Color.values())
+                                        if (color.getSerializedName().startsWith(builder.getRemaining())) builder.suggest(color.getSerializedName());
+                                    return builder.buildFuture();
+                                }).executes(context -> decay(context, 1))
+                                .then(Commands.argument("attempts", IntegerArgumentType.integer(1, 32))
+                                        .executes(context -> decay(context, IntegerArgumentType.getInteger(context, "attempts"))))))
+                        .then(Commands.literal("environment").then(Commands.argument("effect", StringArgumentType.word())
+                                .suggests((context, builder) -> {
+                                    for (String effect : java.util.List.of("burning", "erosion"))
+                                        if (effect.startsWith(builder.getRemaining())) builder.suggest(effect);
+                                    return builder.buildFuture();
+                                }).executes(context -> {
+                                    var source = context.getSource(); requireAge(source);
+                                    String effect = StringArgumentType.getString(context, "effect");
+                                    if (!effect.equals("burning") && !effect.equals("erosion")) {
+                                        source.sendFailure(Component.literal("Choose burning or erosion")); return 0;
+                                    }
+                                    int result = PortEnvironmentalProviders.pulseForTesting(source.getPlayerOrException(), effect);
+                                    if (result > 0) source.sendSuccess(() -> Component.literal("Applied " + effect + "; saved score/plan unchanged"), false);
+                                    else source.sendFailure(Component.literal(result == -2 ? "Burning would be extinguished by water or rain"
+                                            : "No effect applied. Check Age/config/provider policy, spawn protection and sky exposure; burning requires Survival/Adventure, erosion requires score >=10000 and a source fluid beside/above the targeted block."));
+                                    return Math.max(0, result);
+                                })))
+                        .then(Commands.literal("meteor").executes(context -> {
+                            var source = context.getSource(); requireAge(source);
+                            int result = PortMeteorProvider.pulseForTesting(source.getPlayerOrException());
+                            if (result > 0) source.sendSuccess(() -> Component.literal("Meteor descent scheduled; impact in 30 ticks. Saved score/plan unchanged."), false);
+                            else source.sendFailure(Component.literal("No meteor scheduled: check cooldown (200 ticks), active flight, safe loaded terrain and Age/config/provider policy."));
+                            return Math.max(0, result);
+                        }))
+                        .then(Commands.literal("hazard").then(Commands.argument("type", StringArgumentType.word())
+                                .suggests((context, builder) -> {
+                                    for (String type : java.util.List.of("lightning", "explosions"))
+                                        if (type.startsWith(builder.getRemaining())) builder.suggest(type);
+                                    return builder.buildFuture();
+                                }).executes(context -> {
+                                    var source = context.getSource(); var level = requireAge(source);
+                                    String type = StringArgumentType.getString(context, "type");
+                                    if (!type.equals("lightning") && !type.equals("explosions")) {
+                                        source.sendFailure(Component.literal("Choose lightning or explosions")); return 0;
+                                    }
+                                    int result = PortHazardProviders.pulseForTesting(level, BlockPos.containing(source.getPosition()), type.equals("lightning"));
+                                    if (result > 0) source.sendSuccess(() -> Component.literal("Triggered " + type
+                                            + " in a nearby loaded chunk; saved score/plan unchanged"), false);
+                                    else source.sendFailure(Component.literal(result < 0 ? "Hazard disabled by config, Age or provider policy"
+                                            : "No hazard triggered: cooldown, protected spawn, unloaded terrain or event cancellation"));
+                                    return Math.max(0, result);
+                                })))
+                        .then(Commands.literal("pulse").then(Commands.argument("provider", StringArgumentType.word())
+                                .suggests((context, builder) -> {
+                                    for (var deck : InstabilityProviderCatalog.Deck.values()) for (var card : InstabilityProviderCatalog.cards(deck))
+                                        if (card.id().getPath().startsWith(builder.getRemaining())) builder.suggest(card.id().getPath());
+                                    return builder.buildFuture();
+                                }).executes(context -> {
+                                    var source = context.getSource(); var level = requireAge(source);
+                                    String name = StringArgumentType.getString(context, "provider");
+                                    Identifier id = Identifier.tryParse(name.contains(":") ? name : "rivencraft:" + name);
+                                    if (id == null || !InstabilityProviderCatalog.contains(id)) throw new com.mojang.brigadier.exceptions.SimpleCommandExceptionType(Component.literal("Unknown instability provider")).create();
+                                    var chunk = net.minecraft.world.level.ChunkPos.containing(BlockPos.containing(source.getPosition()));
+                                    if (level.getChunkSource().getChunkNow(chunk.x(), chunk.z()) == null)
+                                        throw new com.mojang.brigadier.exceptions.SimpleCommandExceptionType(Component.literal("Current chunk must already be loaded")).create();
+                                    var budget = new PortInstabilityRuntime.Budget(1);
+                                    var effect = new PortInstabilityRuntime.Context(level, PortInstabilityData.get(level.getServer()).age(level),
+                                            java.util.List.of(chunk), source.getServer().getTickCount(), budget);
+                                    boolean attempted = PortInstabilityRuntime.invoke(effect, id, 1);
+                                    boolean applied = attempted && budget.applied() > 0;
+                                    if (applied) source.sendSuccess(() -> Component.literal("Applied " + id + " (" + budget.applied() + " successful action in this chunk)"), false);
+                                    else source.sendFailure(Component.literal("No effect applied. Check eligible targets/terrain, sky exposure, existing effects and protection. Provider status: "
+                                            + PortInstabilityRuntime.providerStatus(level, id)));
+                                    return applied ? 1 : 0;
+                                })))));
+    }
+    private static int decay(com.mojang.brigadier.context.CommandContext<CommandSourceStack> context, int attempts)
+            throws com.mojang.brigadier.exceptions.CommandSyntaxException {
+        requireAge(context.getSource());
+        var color = java.util.Arrays.stream(net.dnorberg.rivencraft.block.DecayBlock.Color.values())
+                .filter(value -> value.getSerializedName().equalsIgnoreCase(StringArgumentType.getString(context, "color")))
+                .findFirst().orElse(null);
+        if (color == null) {
+            context.getSource().sendFailure(Component.literal("Choose blue, purple, red or white")); return 0;
+        }
+        int changed = PortDecayProviders.pulseForTesting(context.getSource().getPlayerOrException(), color, attempts);
+        if (changed < 0) {
+            context.getSource().sendFailure(Component.literal("Decay is disabled by config, Age or provider policy")); return 0;
+        }
+        context.getSource().sendSuccess(() -> Component.literal("Decay " + color.getSerializedName() + ": " + changed
+                + " block changes from " + attempts + " bounded attempts; saved score/plan unchanged"), false);
+        var player = context.getSource().getPlayerOrException();
+        var nearby = PortDecaySavedData.get(player.level()).frontier(color).reversed().stream()
+                .filter(pos -> net.minecraft.world.level.ChunkPos.containing(pos).equals(player.chunkPosition()))
+                .limit(4).map(BlockPos::toShortString).toList();
+        if (!nearby.isEmpty()) context.getSource().sendSuccess(() -> Component.literal("Nearby tracked decay: " + nearby), false);
+        return changed;
+    }
+    private static net.minecraft.server.level.ServerLevel requireAge(CommandSourceStack source)
+            throws com.mojang.brigadier.exceptions.CommandSyntaxException {
+        if (!PortInstabilityRuntime.isAge(source.getLevel())) throw new com.mojang.brigadier.exceptions.SimpleCommandExceptionType(
+                Component.literal("Use this command inside a Rivencraft Age")).create();
+        return source.getLevel();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortInstabilityConfig.java

@@ -0,0 +1,147 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import net.minecraft.resources.Identifier;
+import net.neoforged.neoforge.common.ModConfigSpec;
+
+/** The 1.21.1 scheduler and status-provider defaults, in the port's server-owned config. */
+public final class PortInstabilityConfig {
+    private static ModConfigSpec.BooleanValue enabled, status, players, nonplayers, hostiles, worldMutation, decay;
+    private static ModConfigSpec.IntValue cooldown, ages, providers, actions, level, chunks, active, candidates, duration, decayAttempts;
+    private static ModConfigSpec.ConfigValue<List<? extends String>> disabledProviders;
+    private static ModConfigSpec.BooleanValue hazards, hazardBlocks, hazardPlayers, hazardFire;
+    private static ModConfigSpec.IntValue hazardInterval, hazardChunks, hazardMaxBlocks, hazardEntities, hazardDamage, hazardRadius;
+    private static ModConfigSpec.BooleanValue meteor, meteorBlocks, meteorPlayers, meteorFire;
+    private static ModConfigSpec.IntValue meteorMaxBlocks, meteorEntities, meteorDamage;
+    private static ModConfigSpec.BooleanValue scorch, scorchPlayers, erosion;
+    private static ModConfigSpec.IntValue scorchTargets;
+    private static ModConfigSpec.IntValue difficulty;
+    private static ModConfigSpec.ConfigValue<List<? extends String>> materialOverrides;
+    private PortInstabilityConfig() {}
+    public static void define(ModConfigSpec.Builder builder) {
+        builder.push("instability");
+        enabled = builder.comment("Run implemented instability providers. Saved scores and plans remain unchanged when disabled.")
+                .define("enabled", true);
+        difficulty = builder.comment("Legacy instability difficulty: 0=quarter, 1=half, 2=normal, 3=1.75x; saved scores stay unchanged.")
+                .defineInRange("difficulty", 2, 0, 3);
+        worldMutation = builder.comment("Allow implemented instability providers to change blocks, as in 1.21.1.")
+                .define("world_mutation", true);
+        cooldown = builder.defineInRange("cooldown_ticks", 20, 20, 1200);
+        ages = builder.defineInRange("max_ages_per_tick", 4, 1, 16);
+        providers = builder.defineInRange("max_providers_per_age", 2, 1, 16);
+        actions = builder.defineInRange("max_actions_per_age", 1, 1, 16);
+        level = builder.defineInRange("max_effect_level", 3, 1, 16);
+        chunks = builder.defineInRange("max_loaded_chunks", 16, 1, 64);
+        disabledProviders = builder.comment("Disable particular providers without changing saved selections. Accepts poison or rivencraft:poison.")
+                .defineListAllowEmpty("disabled_providers", List.of(), () -> "poison", value -> value instanceof String text
+                        && Identifier.tryParse(text) != null);
+        builder.pop();
+        builder.push("instability_status_effects");
+        status = builder.define("enabled", true);
+        players = builder.comment("Affect Survival/Adventure players; Creative and Spectator remain exempt.")
+                .define("affect_players", true);
+        nonplayers = builder.define("affect_nonplayers", true);
+        hostiles = builder.define("buff_hostiles", true);
+        active = builder.defineInRange("max_active_per_age", 32, 1, 128);
+        candidates = builder.defineInRange("max_candidates_per_attempt", 8, 1, 16);
+        duration = builder.defineInRange("max_duration_ticks", 200, 20, 200);
+        builder.pop();
+        builder.push("instability_decay");
+        decay = builder.comment("Allow colored decay in loaded Ages. Also requires instability.world_mutation.")
+                .define("enabled", true);
+        decayAttempts = builder.comment("Maximum six-neighbor conversion attempts per provider call; at most one block changes.")
+                .defineInRange("max_attempts_per_call", 4, 1, 6);
+        builder.pop();
+        builder.push("instability_hazards");
+        hazards = builder.comment("Run Legacy lightning and explosion cards in loaded Ages.").define("enabled", true);
+        hazardBlocks = builder.comment("Allow block destruction; also requires world_mutation and mobGriefing.").define("block_damage", true);
+        hazardPlayers = builder.comment("Allow damage to Survival/Adventure players.").define("player_damage", true);
+        hazardFire = builder.comment("Allow ignition where the vanilla fire-spread rule permits it.").define("fire", true);
+        hazardInterval = builder.defineInRange("minimum_gap_ticks", 20, 20, 12000);
+        hazardChunks = builder.defineInRange("max_loaded_chunks", 81, 1, 169);
+        hazardMaxBlocks = builder.defineInRange("max_explosion_blocks", 16, 0, 64);
+        hazardEntities = builder.defineInRange("max_damaged_entities", 8, 0, 32);
+        hazardDamage = builder.defineInRange("max_entity_damage", 12, 0, 40);
+        hazardRadius = builder.comment("Legacy strength 3, bounded to one already-loaded chunk.").defineInRange("explosion_radius", 3, 1, 3);
+        builder.pop();
+        builder.push("instability_meteor");
+        meteor = builder.comment("Run the active Legacy meteor card in loaded Ages.").define("enabled", true);
+        meteorBlocks = builder.comment("Allow impact block destruction; also requires world_mutation and mobGriefing.")
+                .define("block_damage", true);
+        meteorPlayers = builder.comment("Allow impacts to hurt Survival/Adventure players.").define("player_damage", true);
+        meteorFire = builder.comment("Allow impact fire where the vanilla fire-spread rule permits it.").define("fire", true);
+        meteorMaxBlocks = builder.defineInRange("max_impact_blocks", 24, 0, 64);
+        meteorEntities = builder.defineInRange("max_damaged_entities", 8, 0, 32);
+        meteorDamage = builder.defineInRange("max_entity_damage", 12, 0, 40);
+        builder.pop();
+        builder.push("instability_scorching");
+        scorch = builder.comment("Run Legacy's active burning card on sky-exposed entities.").define("enabled", true);
+        scorchPlayers = builder.comment("Allow burning on Survival/Adventure players.").define("affect_players", true);
+        scorchTargets = builder.defineInRange("max_targets_per_pass", 4, 0, 16);
+        builder.pop();
+        builder.push("instability_erosion");
+        erosion = builder.comment("Enable Legacy's dormant erosion effect for testing; no saved card is added.",
+                "Ages with a score of at least 10000 can spread adjacent source fluid into one eligible block per pass.")
+                .define("enabled", true);
+        builder.pop();
+        builder.push("instability_modded_materials");
+        materialOverrides = builder.comment("Recognized ores, mineral blocks and source fluids from installed mods are scored automatically.",
+                "Optional exact modid:block_id=points overrides; zero excludes a block. No content mod is required.")
+                .defineListAllowEmpty("block_weight_overrides", List.of(), () -> "examplemod:rare_ore=4000", PortInstabilityConfig::validMaterialOverride);
+        builder.pop();
+    }
+    private static boolean validMaterialOverride(Object value) {
+        if (!(value instanceof String entry)) return false;
+        int separator = entry.lastIndexOf('=');
+        if (separator < 1) return false;
+        Identifier id = Identifier.tryParse(entry.substring(0, separator));
+        if (id == null || !entry.substring(0, separator).contains(":")
+                || id.getNamespace().equals("minecraft") || id.getNamespace().equals("rivencraft")) return false;
+        try { int weight = Integer.parseInt(entry.substring(separator + 1)); return weight >= 0 && weight <= 100000; }
+        catch (NumberFormatException ignored) { return false; }
+    }
+    public static int instabilityDifficulty() { return difficulty.get(); }
+    public static List<? extends String> moddedMaterialOverrides() { return materialOverrides.get(); }
+    public static boolean scorchEnabled() { return scorch.get(); }
+    public static boolean scorchPlayers() { return scorchPlayers.get(); }
+    public static int scorchMaxTargets() { return scorchTargets.get(); }
+    public static boolean erosionEnabled() { return erosion.get(); }
+    public static boolean meteorEnabled() { return meteor.get(); }
+    public static boolean meteorBlockDamage() { return meteorBlocks.get(); }
+    public static boolean meteorPlayerDamage() { return meteorPlayers.get(); }
+    public static boolean meteorFire() { return meteorFire.get(); }
+    public static int meteorMaxBlocks() { return meteorMaxBlocks.get(); }
+    public static int meteorMaxEntities() { return meteorEntities.get(); }
+    public static int meteorMaxDamage() { return meteorDamage.get(); }
+    public static boolean hazardsEnabled() { return hazards.get(); }
+    public static boolean hazardsBlockDamage() { return hazardBlocks.get(); }
+    public static boolean hazardsPlayerDamage() { return hazardPlayers.get(); }
+    public static boolean hazardsFire() { return hazardFire.get(); }
+    public static int hazardsMinInterval() { return hazardInterval.get(); }
+    public static int hazardsMaxChunks() { return hazardChunks.get(); }
+    public static int hazardsMaxBlocks() { return hazardMaxBlocks.get(); }
+    public static int hazardsMaxEntities() { return hazardEntities.get(); }
+    public static int hazardsMaxDamage() { return hazardDamage.get(); }
+    public static int hazardsExplosionRadius() { return hazardRadius.get(); }
+    public static boolean instabilityWorldMutation() { return worldMutation.get(); }
+    public static boolean decayEnabled() { return decay.get(); }
+    public static int decayMaxAttempts() { return decayAttempts.get(); }
+    public static boolean instabilityEnabled() { return enabled.get(); }
+    public static boolean instabilityProviderEnabled(Identifier id) {
+        return disabledProviders.get().stream().noneMatch(value -> value.equals(id.toString())
+                || id.getNamespace().equals("rivencraft") && value.equals(id.getPath()));
+    }
+    public static int instabilityCooldown() { return cooldown.get(); }
+    public static int instabilityMaxAges() { return ages.get(); }
+    public static int instabilityMaxProviders() { return providers.get(); }
+    public static int instabilityMaxActions() { return actions.get(); }
+    public static int instabilityMaxLevel() { return level.get(); }
+    public static int instabilityMaxChunks() { return chunks.get(); }
+    public static boolean statusEffectsEnabled() { return status.get(); }
+    public static boolean statusEffectsPlayers() { return players.get(); }
+    public static boolean statusEffectsNonplayers() { return nonplayers.get(); }
+    public static boolean statusEffectsHostiles() { return hostiles.get(); }
+    public static int statusEffectsMaxActive() { return active.get(); }
+    public static int statusEffectsMaxCandidates() { return candidates.get(); }
+    public static int statusEffectsMaxDuration() { return duration.get(); }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortInstabilityData.java

@@ -0,0 +1,115 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+/** Frozen creation-time contributions and Legacy deck selections. Never silently rescores older Ages. */
+public final class PortInstabilityData extends SavedData {
+    public record Contribution(String reason, int page, int points) {
+        public static final Codec<Contribution> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                Codec.STRING.fieldOf("reason").forGetter(Contribution::reason),
+                Codec.INT.fieldOf("page").forGetter(Contribution::page),
+                Codec.intRange(0, Integer.MAX_VALUE).fieldOf("points").forGetter(Contribution::points)
+        ).apply(instance, Contribution::new));
+    }
+    public record Age(long seed, List<Contribution> contributions, PortInstabilityPlan plan, boolean enabled, java.util.Optional<net.minecraft.core.BlockPos> spawn) {
+        public static final Codec<Age> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                Codec.LONG.fieldOf("seed").forGetter(Age::seed),
+                Contribution.CODEC.listOf().fieldOf("contributions").forGetter(Age::contributions),
+                PortInstabilityPlan.CODEC.fieldOf("plan").forGetter(Age::plan),
+                Codec.BOOL.optionalFieldOf("enabled", true).forGetter(Age::enabled),
+                net.minecraft.core.BlockPos.CODEC.optionalFieldOf("spawn").forGetter(Age::spawn)
+        ).apply(instance, Age::new));
+        public Age { contributions = List.copyOf(contributions); spawn = spawn.map(net.minecraft.core.BlockPos::immutable); }
+        public Age(long seed, List<Contribution> contributions, PortInstabilityPlan plan, boolean enabled) {
+            this(seed, contributions, plan, enabled, java.util.Optional.empty());
+        }
+        public int score() { return contributions.stream().mapToInt(Contribution::points).reduce(0, Math::addExact); }
+    }
+    private static final SavedDataType<PortInstabilityData> TYPE = new SavedDataType<>(
+            Identifier.fromNamespaceAndPath("rivencraft", "instability"), () -> new PortInstabilityData(Map.of()),
+            Codec.unboundedMap(Identifier.CODEC, Age.CODEC).fieldOf("ages").codec()
+                    .xmap(PortInstabilityData::new, data -> Map.copyOf(data.ages)));
+    private final Map<Identifier, Age> ages = new HashMap<>();
+    private PortInstabilityData(Map<Identifier, Age> values) { ages.putAll(values); }
+    public static PortInstabilityData get(MinecraftServer server) { return server.overworld().getDataStorage().computeIfAbsent(TYPE); }
+    public Age age(ServerLevel level) {
+        Age age = ages.get(level.dimension().identifier());
+        return age != null ? age : new Age(level.getSeed(),
+                List.of(new Contribution("predates_instability", -1, 0)), PortInstabilityPlan.empty(), true);
+    }
+    /** Older neutral Ages stay neutral even if an arrival or enabled flag was later saved. */
+    public boolean supportsProfiling(ServerLevel level) {
+        Age state = ages.get(level.dimension().identifier());
+        return state != null && state.contributions().stream().noneMatch(cost -> cost.reason().equals("predates_instability"));
+    }
+    public void enabled(ServerLevel level, boolean enabled) {
+        Age previous = age(level);
+        ages.put(level.dimension().identifier(), new Age(previous.seed(), previous.contributions(), previous.plan(), enabled, previous.spawn()));
+        setDirty();
+    }
+    /** First resolved arrival remains protected without rescoring or rerolling the Age. */
+    public void recordSpawn(ServerLevel level, net.minecraft.core.BlockPos spawn) {
+        Age previous = age(level);
+        if (previous.spawn().isPresent()) return;
+        ages.put(level.dimension().identifier(), new Age(previous.seed(), previous.contributions(), previous.plan(),
+                previous.enabled(), java.util.Optional.of(spawn.immutable())));
+        setDirty();
+    }
+    public void create(ServerLevel level, List<Identifier> pages, PortAgeTerrain terrain,
+                       PortLighting lighting, PortDayCycle cycle) {
+        Identifier id = level.dimension().identifier();
+        if (ages.containsKey(id)) throw new IllegalArgumentException("Instability already recorded for " + id);
+        List<Contribution> costs = new ArrayList<>();
+        costs.add(new Contribution(pages.isEmpty() ? "random_baseline" : "authored_baseline", -1, 0));
+        for (var diagnostic : net.dnorberg.rivencraft.writing.PortWritingRecovery.recover(pages).diagnostics())
+            costs.add(new Contribution("writing_" + diagnostic.code(), diagnostic.index(), diagnostic.points()));
+        boolean authoredBright = false;
+        Map<Identifier, Integer> structures = new HashMap<>();
+        var biomes = level.getChunkSource().getGenerator().getBiomeSource().possibleBiomes().stream()
+                .flatMap(holder -> holder.unwrapKey().stream()).map(key -> key.identifier()).toList();
+        for (int i = 0; i < pages.size(); i++) {
+            Identifier page = pages.get(i);
+            if (!page.getNamespace().equals("rivencraft")) continue;
+            String path = page.getPath();
+            if (path.equals("lighting/bright")) { costs.add(new Contribution("bright_lighting", i, 500)); authoredBright = true; }
+            if (page.equals(PortAcceleratedTicks.PAGE)) costs.add(new Contribution("accelerated", i, 1000));
+            if (isCorrupted(page)) costs.add(new Contribution("corrupted_" + path.substring(10), i,
+                    path.endsWith("small") ? 2000 : path.endsWith("medium") ? 1000 : 0));
+            // Legacy charges for sky/weather controllers that Cave terrain cannot apply.
+            if (terrain == PortAgeTerrain.CAVE && (PortWeatherMode.forPage(page) != null
+                    || PortDayCycle.isController(page) || PortDayCycle.isPeriod(page)
+                    || PortDayCycle.isPhase(page) || PortDayCycle.isAngle(page) || PortDayCycle.isDirection(page)))
+                costs.add(new Contribution("cave_ignored_" + path.replace('/', '_'), i, 100));
+            if (PortStructurePages.supports(page)) {
+                int count = structures.merge(page, 1, Integer::sum);
+                if (count > 3) costs.add(new Contribution("excess_" + path, i, 100));
+                var allowed = PortStructurePages.compatibleBiomes(page, level.registryAccess());
+                if (!allowed.isEmpty() && biomes.stream().anyMatch(biome -> !allowed.contains(biome)))
+                    costs.add(new Contribution("forced_biome_" + path, i, 100));
+            }
+        }
+        if (lighting == PortLighting.BRIGHT && !authoredBright) costs.add(new Contribution("seeded_bright_lighting", -1, 500));
+        int suns = 0;
+        for (var body : cycle.bodies()) if (body.kind() == PortDayCycle.SUN && ++suns > 2)
+            costs.add(new Contribution("extra_sun_" + suns, -1, 1000 * (suns - 2)));
+        int score = costs.stream().mapToInt(Contribution::points).reduce(0, Math::addExact);
+        ages.put(id, new Age(level.getSeed(), costs, PortInstabilityPlan.select(score, level.getSeed()), true));
+        setDirty();
+    }
+    public static boolean isCorrupted(Identifier page) {
+        return page.getNamespace().equals("rivencraft") && switch (page.getPath()) {
+            case "corrupted/large", "corrupted/medium", "corrupted/small" -> true;
+            default -> false;
+        };
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortInstabilityPlan.java

@@ -0,0 +1,60 @@
+package net.dnorberg.rivencraft.age;
+
+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.resources.Identifier;
+
+/** Frozen provider selection; handler availability and server settings never reroll this plan. */
+public record PortInstabilityPlan(int version, List<ProviderLevel> providers) {
+    public static final com.mojang.serialization.Codec<PortInstabilityPlan> CODEC =
+            com.mojang.serialization.codecs.RecordCodecBuilder.create(instance -> instance.group(
+                    com.mojang.serialization.Codec.INT.fieldOf("version").forGetter(PortInstabilityPlan::version),
+                    ProviderLevel.CODEC.listOf().fieldOf("providers").forGetter(PortInstabilityPlan::providers)
+            ).apply(instance, PortInstabilityPlan::new));
+    public static final int CURRENT_VERSION = 1;
+
+    public PortInstabilityPlan {
+        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 PortInstabilityPlan empty() { return new PortInstabilityPlan(CURRENT_VERSION, List.of()); }
+
+    public static PortInstabilityPlan select(int score, long ageSeed) {
+        int roundedScore = score / 500 * 500;
+        Map<Identifier, 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 PortInstabilityPlan(CURRENT_VERSION, levels.entrySet().stream()
+                .map(entry -> new ProviderLevel(entry.getKey(), entry.getValue())).toList());
+    }
+
+    public record ProviderLevel(Identifier id, int level) {
+        public static final com.mojang.serialization.Codec<ProviderLevel> CODEC =
+                com.mojang.serialization.codecs.RecordCodecBuilder.create(instance -> instance.group(
+                        Identifier.CODEC.fieldOf("id").forGetter(ProviderLevel::id),
+                        com.mojang.serialization.Codec.intRange(1, 255).fieldOf("level").forGetter(ProviderLevel::level)
+                ).apply(instance, ProviderLevel::new));
+        public ProviderLevel {
+            Objects.requireNonNull(id, "id");
+            if (level < 1 || level > 255) throw new IllegalArgumentException("Invalid provider level " + level);
+        }
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortInstabilityRuntime.java

@@ -0,0 +1,178 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.WeakHashMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.ChunkPos;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.neoforge.event.server.ServerStoppingEvent;
+import net.neoforged.neoforge.event.tick.LevelTickEvent;
+
+/** The 1.21.1 bounded Age scheduler. Unported cards remain saved and visibly unavailable to operators. */
+@EventBusSubscriber(modid = Rivencraft.MOD_ID)
+public final class PortInstabilityRuntime {
+    private static final Map<ServerLevel, CachedPlan> PLANS = new WeakHashMap<>();
+    private record CachedPlan(int score, long seed, PortInstabilityPlan plan) {}
+    private static final Map<Identifier, Handler> HANDLERS = new HashMap<>();
+    private static final Map<ServerLevel, Map<Identifier, Long>> FAILURES = new WeakHashMap<>();
+    private static final Map<MinecraftServer, Map<Identifier, Integer>> TEST_SCORES = new WeakHashMap<>();
+    private static final Map<MinecraftServer, TickState> TICKS = new WeakHashMap<>();
+    private PortInstabilityRuntime() {}
+    public static void register(Identifier id, ProviderEffect handler) {
+        register(id, false, handler);
+    }
+    public static void register(Identifier id, boolean worldMutating, ProviderEffect handler) {
+        if (HANDLERS.putIfAbsent(id, new Handler(worldMutating, handler)) != null)
+            throw new IllegalArgumentException("Duplicate instability provider " + id);
+    }
+    public static boolean isAge(ServerLevel level) { return level instanceof PortAgeLevel; }
+    public static PortInstabilityPlan plan(ServerLevel level) {
+        var age = PortInstabilityData.get(level.getServer()).age(level);
+        Integer test = testScore(level);
+        int profile = test == null ? PortBlockInstability.score(level) : 0;
+        int difficulty = PortInstabilityConfig.instabilityDifficulty();
+        if (test == null && difficulty == 2 && profile == 0) return age.plan();
+        int score = test != null ? test : PortBlockInstability.difficultyScore((long) age.score() + profile, difficulty);
+        var cached = PLANS.get(level);
+        if (cached == null || cached.score() != score || cached.seed() != age.seed()) {
+            cached = new CachedPlan(score, age.seed(), PortInstabilityPlan.select(score, age.seed()));
+            PLANS.put(level, cached);
+        }
+        return cached.plan();
+    }
+    public static Integer testScore(ServerLevel level) {
+        return TEST_SCORES.getOrDefault(level.getServer(), Map.of()).get(level.dimension().identifier());
+    }
+    public static int effectiveScore(ServerLevel level) {
+        Integer test = testScore(level);
+        if (test != null) return test;
+        return PortBlockInstability.difficultyScore((long) PortInstabilityData.get(level.getServer()).age(level).score()
+                + PortBlockInstability.score(level), PortInstabilityConfig.instabilityDifficulty());
+    }
+    public static void testScore(ServerLevel level, Integer score) {
+        var values = TEST_SCORES.computeIfAbsent(level.getServer(), ignored -> new HashMap<>());
+        if (score == null) values.remove(level.dimension().identifier()); else values.put(level.dimension().identifier(), score);
+    }
+    @SubscribeEvent public static void tick(LevelTickEvent.Post event) {
+        if (!(event.getLevel() instanceof ServerLevel level) || !isAge(level) || level.players().isEmpty()
+                || !PortInstabilityConfig.instabilityEnabled()) return;
+        var server = level.getServer();
+        long tick = server.getTickCount();
+        int cooldown = PortInstabilityConfig.instabilityCooldown();
+        if (tick % cooldown != 0) return;
+        TickState state = TICKS.computeIfAbsent(server, ignored -> new TickState());
+        if (state.tick != tick) {
+            state.tick = tick;
+            var eligible = new ArrayList<Identifier>();
+            for (var loaded : server.getAllLevels()) if (isAge(loaded) && !loaded.players().isEmpty()
+                    && PortInstabilityData.get(server).age(loaded).enabled() && !plan(loaded).providers().isEmpty())
+                eligible.add(loaded.dimension().identifier());
+            eligible.sort(Comparator.comparing(Identifier::toString));
+            state.eligible = List.copyOf(eligible);
+        }
+        int index = state.eligible.indexOf(level.dimension().identifier());
+        if (index < 0 || state.eligible.size() > PortInstabilityConfig.instabilityMaxAges()
+                && Math.floorMod(index - (int) Math.floorMod(tick / cooldown, state.eligible.size()), state.eligible.size())
+                    >= PortInstabilityConfig.instabilityMaxAges()) return;
+        var age = PortInstabilityData.get(server).age(level);
+        if (!age.enabled()) return;
+        var providers = plan(level).providers();
+        PortHazardProviders.tickPlanned(level, age, tick, providers);
+        PortMeteorProvider.tickPlanned(level, age, tick, providers);
+        PortEnvironmentalProviders.tickPlanned(level, age, tick, providers);
+        var chunks = loadedChunks(level);
+        if (providers.isEmpty() || chunks.isEmpty()) return;
+        Context context = new Context(level, age, chunks, tick, new Budget(PortInstabilityConfig.instabilityMaxActions()));
+        int first = (int) Math.floorMod(tick / cooldown + age.seed(), providers.size());
+        int ran = 0;
+        for (int offset = 0; offset < providers.size() && ran < PortInstabilityConfig.instabilityMaxProviders()
+                && context.budget().remaining() > 0; offset++) {
+            var provider = providers.get((first + offset) % providers.size());
+            if (!PortHazardProviders.isHazard(provider.id()) && !provider.id().equals(PortMeteorProvider.METEORS)
+                    && !PortEnvironmentalProviders.isEnvironmental(provider.id()) && invoke(context, provider.id(), provider.level())) ran++;
+        }
+    }
+    public static boolean invoke(Context context, Identifier id, int level) {
+        if (!PortInstabilityConfig.instabilityEnabled() || !PortInstabilityConfig.instabilityProviderEnabled(id)
+                || !PortInstabilityData.get(context.level().getServer()).age(context.level()).enabled()) return false;
+        Handler handler = HANDLERS.get(id);
+        if (handler == null || handler.worldMutating() && !PortInstabilityConfig.instabilityWorldMutation()) return false;
+        var failures = FAILURES.computeIfAbsent(context.level(), ignored -> new HashMap<>());
+        if (context.serverTick() < failures.getOrDefault(id, 0L)) return false;
+        try {
+            handler.effect().apply(context, id, Math.min(level, PortInstabilityConfig.instabilityMaxLevel()));
+        } catch (RuntimeException exception) {
+            failures.put(id, context.serverTick() + Math.max(200L, PortInstabilityConfig.instabilityCooldown() * 10L));
+            Rivencraft.LOGGER.error("Instability provider {} failed in {}; temporarily quarantined", id,
+                    context.level().dimension().identifier(), exception);
+        }
+        return true;
+    }
+    public static String providerStatus(ServerLevel level, Identifier id) {
+        if (!HANDLERS.containsKey(id)) return "not ported yet";
+        if (!PortInstabilityConfig.instabilityEnabled()) return "global config off";
+        if (!PortInstabilityData.get(level.getServer()).age(level).enabled()) return "Age disabled";
+        if (!PortInstabilityConfig.instabilityProviderEnabled(id)) return "provider config off";
+        if (PortHazardProviders.isHazard(id)) {
+            if (!PortInstabilityConfig.hazardsEnabled()) return "hazards config off";
+        } else if (id.equals(PortMeteorProvider.METEORS)) {
+            if (!PortInstabilityConfig.meteorEnabled()) return "meteor config off";
+        } else if (id.equals(PortEnvironmentalProviders.BURNING)) {
+            if (!PortInstabilityConfig.scorchEnabled()) return "burning config off";
+            if (PortInstabilityConfig.scorchMaxTargets() == 0) return "burning target budget zero";
+        } else if (HANDLERS.get(id).worldMutating()) {
+            if (!PortInstabilityConfig.instabilityWorldMutation()) return "world mutation off";
+            if (id.getPath().startsWith("decay") && !PortInstabilityConfig.decayEnabled()) return "decay config off";
+            if (id.equals(PortEnvironmentalProviders.EROSION)) {
+                if (!PortInstabilityConfig.erosionEnabled()) return "erosion config off";
+                if (!PortHazardProviders.canMutate(level)) return "mobGriefing off";
+                if (effectiveScore(level) < InstabilityProviderCatalog.Deck.DESTRUCTIVE.entryCost()) return "erosion threshold not met";
+            }
+        } else {
+            if (!PortInstabilityConfig.statusEffectsEnabled()) return "status effects config off";
+            if (id.getPath().startsWith("enemy") && !PortInstabilityConfig.statusEffectsHostiles()) return "hostile buffs disabled";
+            if (!id.getPath().startsWith("enemy") && !PortInstabilityConfig.statusEffectsPlayers()
+                    && !PortInstabilityConfig.statusEffectsNonplayers()) return "all general targets disabled";
+        }
+        if (level.getServer().getTickCount() < FAILURES.getOrDefault(level, Map.of()).getOrDefault(id, 0L)) return "quarantined";
+        return level.players().isEmpty() ? "no players in Age" : "eligible; sky, targets and budgets still apply";
+    }
+    static List<ChunkPos> loadedChunks(ServerLevel level) {
+        var chunks = new LinkedHashSet<ChunkPos>();
+        for (var player : level.players()) {
+            ChunkPos center = player.chunkPosition();
+            for (int x = -1; x <= 1; x++) for (int z = -1; z <= 1; z++) {
+                if (level.getChunkSource().getChunkNow(center.x() + x, center.z() + z) != null)
+                    chunks.add(new ChunkPos(center.x() + x, center.z() + z));
+                if (chunks.size() >= PortInstabilityConfig.instabilityMaxChunks()) return List.copyOf(chunks);
+            }
+        }
+        return List.copyOf(chunks);
+    }
+    @SubscribeEvent public static void stopping(ServerStoppingEvent event) {
+        TEST_SCORES.remove(event.getServer()); TICKS.remove(event.getServer()); FAILURES.clear(); PLANS.clear();
+    }
+    public interface ProviderEffect { void apply(Context context, Identifier id, int level); }
+    public record Context(ServerLevel level, PortInstabilityData.Age age, List<ChunkPos> loadedChunks,
+                          long serverTick, Budget budget) { public Context { loadedChunks = List.copyOf(loadedChunks); } }
+    public static final class Budget {
+        private int remaining;
+        private int applied;
+        public Budget(int maximum) { remaining = maximum; }
+        public boolean claim() { if (remaining <= 0) return false; remaining--; return true; }
+        public int remaining() { return remaining; }
+        public void recordApplied() { applied++; }
+        public int applied() { return applied; }
+    }
+    private record Handler(boolean worldMutating, ProviderEffect effect) {}
+    private static final class TickState { long tick = Long.MIN_VALUE; List<Identifier> eligible = List.of(); }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortLakePlan.java

@@ -0,0 +1,46 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.resources.Identifier;
+
+/** Ordered lake pages with fluid choices frozen when the Age is bound. */
+public record PortLakePlan(List<Choice> choices) {
+    public static final Codec<PortLakePlan> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            Choice.CODEC.listOf().fieldOf("choices").forGetter(PortLakePlan::choices)
+    ).apply(instance, PortLakePlan::new));
+
+    public record Choice(Identifier page, Identifier fluid) {
+        public static final Codec<Choice> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                Identifier.CODEC.fieldOf("page").forGetter(Choice::page),
+                Identifier.CODEC.fieldOf("fluid").forGetter(Choice::fluid)
+        ).apply(instance, Choice::new));
+
+        public Choice {
+            if (!isLake(page) || fluid == null) throw new IllegalArgumentException("Invalid lake choice");
+        }
+    }
+
+    public PortLakePlan {
+        choices = List.copyOf(choices);
+        if (choices.isEmpty() || choices.size() > 32)
+            throw new IllegalArgumentException("Lake plan must contain 1–32 choices");
+    }
+
+    public static boolean isLake(Identifier page) {
+        if (page == null || !page.getNamespace().equals(Rivencraft.MOD_ID)) return false;
+        return switch (page.getPath()) {
+            case "feature/surface_lakes", "feature/deep_lakes", "feature/lava_lakes" -> true;
+            default -> false;
+        };
+    }
+
+    public static boolean isDeep(Identifier page) { return page.getPath().equals("feature/deep_lakes"); }
+
+    public static Identifier placedFeature(Identifier page) {
+        if (!isLake(page)) throw new IllegalArgumentException("Unsupported lake page " + page);
+        return Identifier.withDefaultNamespace(isDeep(page) ? "lake_lava_underground" : "lake_lava_surface");
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortLibraryCommands.java

@@ -0,0 +1,121 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import net.minecraft.commands.Commands;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.phys.Vec3;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.neoforge.event.RegisterCommandsEvent;
+
+/** Explicit operator tools; normal generation does not search or force-load remote chunks. */
+@EventBusSubscriber(modid = "rivencraft")
+public final class PortLibraryCommands {
+    @SubscribeEvent public static void register(RegisterCommandsEvent event) {
+        var root = Commands.literal("rivencraft_port").requires(Commands.hasPermission(Commands.LEVEL_ADMINS));
+        root.then(Commands.literal("library")
+                .then(Commands.literal("test_place").executes(context -> {
+                    var level = context.getSource().getLevel();
+                    var direction = context.getSource().getEntity() instanceof net.minecraft.world.entity.player.Player player
+                            ? player.getDirection() : net.minecraft.core.Direction.NORTH;
+                    var result = PortLibraryFeature.testPlace(level, BlockPos.containing(context.getSource().getPosition()), direction,
+                            level.getSeed(), PortLibraryWriting.get(level.getServer()).symbols(level.dimension().identifier()));
+                    if (result.isEmpty()) { context.getSource().sendFailure(Component.literal("No clear placement nearby; use open ground with headroom.")); return 0; }
+                    context.getSource().sendSuccess(() -> Component.literal("Library placed. Chest: " + result.get().toShortString()), false);
+                    return 1;
+                }))
+                .then(Commands.literal("test_spacing").then(Commands.argument("chunks", IntegerArgumentType.integer(1, 32))
+                        .executes(context -> {
+                            var level = context.getSource().getLevel();
+                            if (!RuntimeAgeBackend.savedAges(level.getServer()).containsKey(level.dimension().identifier()))
+                                throw new IllegalArgumentException("Use this test override inside a Rivencraft Age");
+                            int spacing = IntegerArgumentType.getInteger(context, "chunks");
+                            PortLibraryFeature.setTestSpacing(level.getSeed(), spacing);
+                            context.getSource().sendSuccess(() -> Component.literal("Session-only library spacing: " + spacing
+                                    + " chunks. Applies to newly generated chunks; 32 restores normal spacing."), false);
+                            return 1;
+                        })))
+                .then(Commands.literal("candidate").executes(context -> {
+                    var level = context.getSource().getLevel();
+                    var origin = ChunkPos.containing(BlockPos.containing(context.getSource().getPosition()));
+                    ChunkPos best = null;
+                    long distance = Long.MAX_VALUE;
+                    for (int spacing : new int[]{32, PortLibraryFeature.spacing(level.getSeed())}) {
+                        int rx = Math.floorDiv(origin.x(), spacing), rz = Math.floorDiv(origin.z(), spacing);
+                        for (int dx = -2; dx <= 2; dx++) for (int dz = -2; dz <= 2; dz++) {
+                            var candidate = PortLibraryFeature.candidateChunk(level.getSeed(), rx + dx, rz + dz, spacing);
+                            long x = candidate.x() - origin.x(), z = candidate.z() - origin.z();
+                            long d = x * x + z * z;
+                            if (d < distance) { best = candidate; distance = d; }
+                        }
+                    }
+                    var candidate = best;
+                    context.getSource().sendSuccess(() -> Component.literal("Nearest candidate chunk " + candidate
+                            + ", center X=" + (candidate.getMinBlockX() + 8) + " Z=" + (candidate.getMinBlockZ() + 8)
+                            + ". A candidate is not a guaranteed library: footing, slope and clear space must pass."), false);
+                    return 1;
+                }))
+                .then(Commands.literal("probe").executes(context -> {
+                    var level = context.getSource().getLevel();
+                    var chunk = level.getChunkAt(BlockPos.containing(context.getSource().getPosition()));
+                    var chest = PortLibraryFeature.libraryChest(chunk);
+                    if (chest.isPresent()) context.getSource().sendSuccess(() -> Component.literal("Generated library chest: " + chest.get().toShortString()), false);
+                    else {
+                        var check = PortLibraryFeature.check(level, chunk.getPos(), level.getSeed());
+                        context.getSource().sendSuccess(() -> Component.literal(check.eligible() ? "Eligible library candidate, floor Y=" + check.floorY()
+                                : "No library in this chunk: " + check.reason()), false);
+                    }
+                    return 1;
+                }))
+                .then(Commands.literal("inspect_loot").executes(context -> {
+                    var level = context.getSource().getLevel();
+                    var chunk = level.getChunkAt(BlockPos.containing(context.getSource().getPosition()));
+                    var pos = PortLibraryFeature.libraryChest(chunk);
+                    if (pos.isEmpty()) { context.getSource().sendFailure(Component.literal("No marked library chest in this chunk.")); return 0; }
+                    var chest = (net.minecraft.world.level.block.entity.ChestBlockEntity) level.getBlockEntity(pos.get());
+                    var items = new java.util.ArrayList<String>();
+                    for (int i = 0; i < chest.getContainerSize(); i++) {
+                        var item = chest.getItem(i); // Materializes loot exactly as opening the chest does.
+                        if (!item.isEmpty()) items.add(item.getCount() + "x " + item.getHoverName().getString());
+                    }
+                    long stands = chunk.getBlockEntities().values().stream()
+                            .filter(be -> be instanceof net.dnorberg.rivencraft.block.entity.BookStandBlockEntity).count();
+                    context.getSource().sendSuccess(() -> Component.literal("Library at " + pos.get().toShortString()
+                            + "; stands in this chunk=" + stands + "; chest=" + items), false);
+                    return 1;
+                }))
+                .then(Commands.literal("nearest_loaded").executes(context -> {
+                    var player = context.getSource().getPlayerOrException();
+                    var level = player.level();
+                    var origin = player.chunkPosition();
+                    BlockPos best = null; double distance = Double.MAX_VALUE;
+                    for (int x = origin.x() - 16; x <= origin.x() + 16; x++) for (int z = origin.z() - 16; z <= origin.z() + 16; z++) {
+                        var chunk = level.getChunkSource().getChunkNow(x, z);
+                        if (chunk == null) continue;
+                        var found = PortLibraryFeature.libraryChest(chunk);
+                        if (found.isPresent()) {
+                            double d = player.distanceToSqr(Vec3.atCenterOf(found.get()));
+                            if (d < distance) { best = found.get(); distance = d; }
+                        }
+                    }
+                    if (best == null) { context.getSource().sendFailure(Component.literal("No library in loaded chunks within 16 chunks. Use candidate or test_spacing to explore new terrain.")); return 0; }
+                    var facing = level.getBlockState(best).getValue(ChestBlock.FACING);
+                    var feet = best.relative(facing, 2).relative(facing.getCounterClockWise());
+                    var target = Vec3.atBottomCenterOf(feet);
+                    if (!level.getBlockState(feet.below()).isFaceSturdy(level, feet.below(), net.minecraft.core.Direction.UP)
+                            || !level.getFluidState(feet).isEmpty() || !level.getFluidState(feet.above()).isEmpty()
+                            || !level.noCollision(player, player.getBoundingBox().move(target.subtract(player.position())))) {
+                        context.getSource().sendFailure(Component.literal("Library found at " + best.toShortString() + " but its aisle is obstructed.")); return 0;
+                    }
+                    player.teleportTo(level, target.x, target.y, target.z, java.util.Set.of(), facing.getOpposite().toYRot(), 0, true);
+                    return 1;
+                })));
+        event.getDispatcher().register(root);
+    }
+    @SubscribeEvent public static void stopped(net.neoforged.neoforge.event.server.ServerStoppedEvent event) {
+        PortLibraryFeature.clearTestSpacing();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortLibraryFeature.java

@@ -0,0 +1,358 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import net.dnorberg.rivencraft.PortConfig;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.PortSymbolPages;
+import net.dnorberg.rivencraft.block.BookStandBlock;
+import net.dnorberg.rivencraft.block.entity.BookStandBlockEntity;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.Identifier;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.entity.ChestBlockEntity;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.levelgen.LegacyRandomSource;
+import net.minecraft.world.level.levelgen.WorldgenRandom;
+import net.minecraft.world.level.storage.loot.LootTable;
+import net.minecraft.world.level.block.Rotation;
+import net.minecraft.world.level.levelgen.structure.templatesystem.StructurePlaceSettings;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+/** Sparse, page-free Age library. Its entire footprint lives in its candidate chunk. */
+public final class PortLibraryFeature {
+    public static final int REGION = 32;
+    static final int FOOTPRINT = 11;
+    private static final int OFFSET_BOUND = 24;
+    private static final int MAX_SUPPORT_DEPTH = 24;
+    private static final int SALT = 14357617;
+    private static final int TEST_SALT = 0x4C494252;
+    private static final String CHEST_MARKER = "RivencraftLibrary";
+    private static final ConcurrentHashMap<Long, Integer> TEST_SPACING = new ConcurrentHashMap<>();
+    // x, y, z, clockwise turns relative to the left stand. The middle row
+    // faces across the room; the far stand faces back toward the entrance.
+    private static final int[][] STANDS = {{6, 1, 2, 0}, {8, 1, 4, 1}, {8, 1, 5, 1},
+            {8, 1, 6, 1}, {6, 1, 8, 2}};
+    private static final Identifier TEMPLATE = Identifier.fromNamespaceAndPath(
+            "rivencraft", "mystcraft_library");
+    private static final ResourceKey<LootTable> CHEST_LOOT = ResourceKey.create(Registries.LOOT_TABLE,
+            Identifier.fromNamespaceAndPath("rivencraft", "chests/mystcraft_library"));
+
+    private PortLibraryFeature() {}
+
+    record Site(int x, int z, int rotation) {}
+
+    public static int spacing(long seed) {
+        return TEST_SPACING.getOrDefault(seed, REGION);
+    }
+
+    /** Session-only testing override; normal 32-chunk sites always remain eligible. */
+    public static void setTestSpacing(long seed, int chunks) {
+        if (chunks < 1 || chunks > REGION) throw new IllegalArgumentException("Invalid library spacing " + chunks);
+        if (chunks == REGION) TEST_SPACING.remove(seed);
+        else TEST_SPACING.put(seed, chunks);
+    }
+
+    public static void clearTestSpacing() {
+        TEST_SPACING.clear();
+    }
+
+    /** The single deterministic candidate in one Legacy-sized region. */
+    public static ChunkPos candidateChunk(long seed, int regionX, int regionZ) {
+        return candidateChunk(seed, regionX, regionZ, REGION);
+    }
+
+    public static ChunkPos candidateChunk(long seed, int regionX, int regionZ, int spacing) {
+        if (spacing < 1 || spacing > REGION) throw new IllegalArgumentException("Invalid library spacing " + spacing);
+        WorldgenRandom random = new WorldgenRandom(new LegacyRandomSource(0L));
+        random.setLargeFeatureWithSalt(seed, regionX, regionZ,
+                spacing == REGION ? SALT : TEST_SALT ^ spacing);
+        int bound = spacing == REGION ? OFFSET_BOUND : spacing;
+        return new ChunkPos(regionX * spacing + random.nextInt(bound),
+                regionZ * spacing + random.nextInt(bound));
+    }
+
+    static Site site(long seed, ChunkPos chunk) {
+        Site normal = site(seed, chunk, REGION);
+        return normal != null ? normal : spacing(seed) == REGION ? null : site(seed, chunk, spacing(seed));
+    }
+
+    private static Site site(long seed, ChunkPos chunk, int spacing) {
+        int rx = Math.floorDiv(chunk.x(), spacing);
+        int rz = Math.floorDiv(chunk.z(), spacing);
+        WorldgenRandom random = new WorldgenRandom(new LegacyRandomSource(0L));
+        random.setLargeFeatureWithSalt(seed, rx, rz,
+                spacing == REGION ? SALT : TEST_SALT ^ spacing);
+        int bound = spacing == REGION ? OFFSET_BOUND : spacing;
+        int candidateX = rx * spacing + random.nextInt(bound);
+        int candidateZ = rz * spacing + random.nextInt(bound);
+        if (chunk.x() != candidateX || chunk.z() != candidateZ) return null;
+        return new Site(chunk.getMinBlockX() + 2, chunk.getMinBlockZ() + 2, random.nextInt(4));
+    }
+
+    /** A saved marker distinguishes a generated library from player-built chests. */
+    public static Optional<BlockPos> libraryChest(LevelChunk chunk) {
+        return chunk.getBlockEntities().entrySet().stream()
+                .filter(entry -> entry.getValue() instanceof ChestBlockEntity chest
+                        && chest.getPersistentData().getBooleanOr(CHEST_MARKER, false))
+                .map(java.util.Map.Entry::getKey).findFirst();
+    }
+
+    /** Recognize libraries generated before the chest marker was introduced. */
+    public static Optional<BlockPos> libraryChest(LevelChunk chunk, long seed) {
+        Optional<BlockPos> marked = libraryChest(chunk);
+        if (marked.isPresent()) return marked;
+        Site site = site(seed, chunk.getPos());
+        if (site == null) return Optional.empty();
+        for (var entry : chunk.getBlockEntities().entrySet()) {
+            if (!(entry.getValue() instanceof ChestBlockEntity chest)) continue;
+            int y = entry.getKey().getY();
+            BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
+            if (!entry.getKey().equals(mapped(site, cursor, 4, y, 2))
+                    || !chunk.getBlockState(mapped(site, cursor, 2, y, 2)).is(Blocks.BOOKSHELF)
+                    || !chunk.getBlockState(mapped(site, cursor, 2, y + 1, 2)).is(Blocks.BOOKSHELF)
+                    || !chunk.getBlockState(mapped(site, cursor, 4, y + 6, 2)).is(Blocks.OAK_PLANKS))
+                continue;
+            chest.getPersistentData().putBoolean(CHEST_MARKER, true);
+            chest.setChanged();
+            return Optional.of(entry.getKey());
+        }
+        return Optional.empty();
+    }
+
+    /** Open interior aisle, directly above the cobblestone floor. */
+    public static BlockPos arrival(long seed, ChunkPos chunk, int chestY) {
+        Site site = site(seed, chunk);
+        if (site == null) throw new IllegalArgumentException("Not a library candidate chunk: " + chunk);
+        return mapped(site, new BlockPos.MutableBlockPos(), 5, chestY, 4).immutable();
+    }
+
+    public record PlacementCheck(String reason, int floorY, int[][] heights) {
+        public boolean eligible() { return reason == null; }
+    }
+
+    /** Inspect one candidate without placing blocks. The same test gates natural placement. */
+    public static PlacementCheck check(WorldGenLevel level, ChunkPos chunk, long seed) {
+        Site site = site(seed, chunk);
+        if (site == null) return rejected("not a candidate chunk");
+        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
+        int low = Integer.MAX_VALUE;
+        int high = Integer.MIN_VALUE;
+        int[][] heights = new int[FOOTPRINT][FOOTPRINT];
+        for (int x = 0; x < FOOTPRINT; x++) for (int z = 0; z < FOOTPRINT; z++) {
+            int wx = site.x() + x;
+            int wz = site.z() + z;
+            int y = level.getHeight(Heightmap.Types.WORLD_SURFACE_WG, wx, wz);
+            // The heightmap includes tree canopies. Libraries sit on terrain, not leaves.
+            while (y > level.getMinY() + 2) {
+                BlockState below = level.getBlockState(cursor.set(wx, y - 1, wz));
+                if (!below.isAir() && !isVegetation(below)) break;
+                y--;
+            }
+            if (y < level.getMinY() + 2) return rejected("no surface footing");
+            BlockState ground = level.getBlockState(cursor.set(wx, y - 1, wz));
+            if (!ground.getFluidState().isEmpty()) return rejected("fluid at ground level");
+            if (ground.hasBlockEntity() || !ground.isFaceSturdy(level, cursor, Direction.UP))
+                return rejected("ground is not sturdy terrain");
+            heights[x][z] = y;
+            low = Math.min(low, y);
+            high = Math.max(high, y);
+        }
+        if (high + 10 >= level.getMaxY()) return rejected("insufficient build height");
+        if (high - low > MAX_SUPPORT_DEPTH) return rejected("slope exceeds support depth ("
+                + (high - low) + " > " + MAX_SUPPORT_DEPTH + ")");
+        // Check the entire raised foundation and house. Foliage can be cleared, but not
+        // structures, fluids, or block entities already occupying this volume.
+        for (int x = 0; x < FOOTPRINT; x++) for (int z = 0; z < FOOTPRINT; z++)
+            for (int y = heights[x][z]; y <= high + 10; y++) {
+                BlockState state = level.getBlockState(cursor.set(site.x() + x, y, site.z() + z));
+                if (!state.getFluidState().isEmpty()) return rejected("fluid inside footprint");
+                if (state.hasBlockEntity()) return rejected("block entity inside footprint");
+                if (!(state.isAir() || state.canBeReplaced() || isVegetation(state)))
+                    return rejected("solid obstruction inside footprint: "
+                            + state.getBlock().getDescriptionId());
+            }
+        return new PlacementCheck(null, high, heights);
+    }
+
+    private static PlacementCheck rejected(String reason) {
+        return new PlacementCheck(reason, 0, null);
+    }
+
+    private static boolean isVegetation(BlockState state) {
+        return state.is(BlockTags.LEAVES) || state.is(BlockTags.LOGS)
+                || state.is(BlockTags.FLOWERS) || state.is(BlockTags.SAPLINGS)
+                || !state.isAir() && state.canBeReplaced() && state.getFluidState().isEmpty();
+    }
+
+    static boolean generate(WorldGenLevel level, ChunkAccess chunk, long seed,
+                            List<Identifier> ageSymbols) {
+        Site site = site(seed, chunk.getPos());
+        if (site == null) return false;
+        PlacementCheck check = check(level, chunk.getPos(), seed);
+        if (!check.eligible()) return false;
+        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
+        for (int x = 0; x < FOOTPRINT; x++) for (int z = 0; z < FOOTPRINT; z++)
+            for (int y = check.heights()[x][z]; y <= check.floorY() + 10; y++) {
+                BlockPos pos = cursor.set(site.x() + x, y, site.z() + z);
+                if (isVegetation(level.getBlockState(pos))) level.setBlock(pos, Blocks.AIR.defaultBlockState(), 2);
+            }
+        return build(level, site, check.floorY(), check.heights(), seed, ageSymbols);
+    }
+
+    /** Explicit OP testing placement. Never overwrites existing blocks or entities. */
+    public static Optional<BlockPos> testPlace(ServerLevel level, BlockPos playerPos, Direction facing,
+                                               long seed, List<Identifier> ageSymbols) {
+        Direction horizontal = facing.getAxis().isHorizontal() ? facing : Direction.NORTH;
+        BlockPos center = playerPos.relative(horizontal, 13);
+        int rotation = switch (horizontal) {
+            case NORTH -> 2;
+            case EAST -> 3;
+            case WEST -> 1;
+            default -> 0;
+        };
+        Site site = new Site(center.getX() - FOOTPRINT / 2, center.getZ() - FOOTPRINT / 2, rotation);
+        int floorY = playerPos.getY() + 2;
+        for (int x = 0; x < FOOTPRINT; x++) for (int z = 0; z < FOOTPRINT; z++)
+            floorY = Math.max(floorY, level.getHeight(Heightmap.Types.WORLD_SURFACE,
+                    site.x() + x, site.z() + z) + 1);
+        if (floorY + 10 >= level.getMaxY() || floorY - playerPos.getY() > 20)
+            return Optional.empty();
+        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
+        for (int x = 0; x < FOOTPRINT; x++) for (int z = 0; z < FOOTPRINT; z++)
+            for (int y = floorY; y <= floorY + 10; y++) {
+                BlockPos pos = cursor.set(site.x() + x, y, site.z() + z);
+                if (!level.getWorldBorder().isWithinBounds(pos) || !level.getBlockState(pos).isAir())
+                    return Optional.empty();
+            }
+        if (!level.getEntities(null, new AABB(site.x(), floorY, site.z(),
+                site.x() + FOOTPRINT, floorY + 11, site.z() + FOOTPRINT)).isEmpty())
+            return Optional.empty();
+        if (!build(level, site, floorY, null, seed, ageSymbols)) return Optional.empty();
+        return Optional.of(mapped(site, cursor, 4, floorY + 1, 2).immutable());
+    }
+
+    private static boolean build(WorldGenLevel level, Site site, int floorY, int[][] heights,
+                                 long seed, List<Identifier> ageSymbols) {
+        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
+        var template = level.getLevel().getStructureTemplateManager().get(TEMPLATE).orElse(null);
+        if (template == null || template.getSize().getX() != FOOTPRINT
+                || template.getSize().getY() != FOOTPRINT || template.getSize().getZ() != FOOTPRINT)
+            return false;
+        for (int x = 0; x < FOOTPRINT; x++) for (int z = 0; z < FOOTPRINT; z++) {
+            for (int y = heights == null ? floorY : heights[x][z] - 1; y <= floorY; y++)
+                place(level, site, cursor, x, y, z, Blocks.COBBLESTONE.defaultBlockState());
+        }
+        Rotation rotation = switch (site.rotation()) {
+            case 1 -> Rotation.CLOCKWISE_90;
+            case 2 -> Rotation.CLOCKWISE_180;
+            case 3 -> Rotation.COUNTERCLOCKWISE_90;
+            default -> Rotation.NONE;
+        };
+        BlockPos origin = new BlockPos(site.x(), floorY, site.z());
+        var settings = new StructurePlaceSettings().setRotation(rotation)
+                .setRotationPivot(new BlockPos(5, 0, 5)).setIgnoreEntities(true);
+        long positionSalt = new ChunkPos(site.x() >> 4, site.z() >> 4).pack();
+        if (!template.placeInWorld(level, origin, origin, settings,
+                RandomSource.create(seed ^ positionSalt), 2)) return false;
+
+        BlockPos chestPos = mapped(site, cursor, 4, floorY + 1, 2).immutable();
+        level.setBlock(chestPos, Blocks.CHEST.defaultBlockState().setValue(ChestBlock.FACING,
+                Direction.from2DDataValue(site.rotation())), 2);
+        PortConfig.LibraryLootMode mode = PortConfig.LIBRARY_LOOT_MODE.get();
+        boolean ageOnly = mode == PortConfig.LibraryLootMode.AGE_ONLY;
+        List<Identifier> symbols = symbolsForLoot(ageSymbols, mode);
+        RandomSource random = RandomSource.create(seed ^ positionSalt ^ SALT);
+        if (level.getBlockEntity(chestPos) instanceof ChestBlockEntity chest) {
+            chest.getPersistentData().putBoolean(CHEST_MARKER, true);
+            chest.setChanged();
+            if (ageOnly) {
+                // Pages are frozen in the Age generator, then saved as real chest items.
+                boolean[] occupied = new boolean[chest.getContainerSize()];
+                for (int i = 0, count = symbols.isEmpty() ? 0 : 4 + random.nextInt(5); i < count; i++) {
+                    int slot;
+                    do slot = random.nextInt(occupied.length); while (occupied[slot]);
+                    occupied[slot] = true;
+                    chest.setItem(slot, page(symbols, random));
+                }
+            } else {
+                chest.setLootTable(CHEST_LOOT, seed ^ chestPos.asLong());
+            }
+        }
+        for (int[] standCoords : STANDS) {
+            BlockPos pos = mapped(site, cursor, standCoords[0], floorY + standCoords[1], standCoords[2]).immutable();
+            if (!level.getBlockState(pos).isAir()) continue;
+            level.setBlock(pos, Rivencraft.BOOK_STAND.get().defaultBlockState()
+                    .setValue(BookStandBlock.FACING, standFacing(site, standCoords[3]))
+                    .setValue(BookStandBlock.HAS_BOOK, true), 2);
+            if (level.getBlockEntity(pos) instanceof BookStandBlockEntity stand) {
+                stand.setBook(symbols.isEmpty() ? new ItemStack(Items.BOOK) : page(symbols, random));
+            }
+        }
+        return true;
+    }
+
+    static Direction standFacing(Site site, int clockwiseTurns) {
+        return Direction.from2DDataValue((site.rotation() + clockwiseTurns) & 3);
+    }
+
+    /** Correct older generated stands in place, retaining their block entities and pages. */
+    public static int repairStandFacings(ServerLevel level, LevelChunk chunk, long seed) {
+        Site site = site(seed, chunk.getPos());
+        if (site == null || libraryChest(chunk, seed).isEmpty()) return -1;
+        int changed = 0;
+        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
+        int chestY = libraryChest(chunk, seed).orElseThrow().getY();
+        for (int[] standCoords : STANDS) {
+            BlockPos pos = mapped(site, cursor, standCoords[0], chestY, standCoords[2]);
+            BlockState state = level.getBlockState(pos);
+            if (!state.is(Rivencraft.BOOK_STAND.get())) continue;
+            Direction facing = standFacing(site, standCoords[3]);
+            if (state.getValue(BookStandBlock.FACING) != facing) {
+                level.setBlock(pos, state.setValue(BookStandBlock.FACING, facing), 3);
+                changed++;
+            }
+        }
+        return changed;
+    }
+
+    static List<Identifier> symbolsForLoot(List<Identifier> ageSymbols, PortConfig.LibraryLootMode mode) {
+        return mode == PortConfig.LibraryLootMode.AGE_ONLY
+                ? ageSymbols.stream().filter(id -> PortSymbolPages.find(id) != null).distinct().toList()
+                : PortSymbolPages.sealedCandidateIds();
+    }
+
+    private static ItemStack page(List<Identifier> symbols, RandomSource random) {
+        return PageItem.createSymbolPage(symbols.get(random.nextInt(symbols.size())));
+    }
+
+    private static BlockPos.MutableBlockPos mapped(Site site, BlockPos.MutableBlockPos cursor, int x, int y, int z) {
+        return switch (site.rotation()) {
+            case 1 -> cursor.set(site.x() + FOOTPRINT - 1 - z, y, site.z() + x);
+            case 2 -> cursor.set(site.x() + FOOTPRINT - 1 - x, y, site.z() + FOOTPRINT - 1 - z);
+            case 3 -> cursor.set(site.x() + z, y, site.z() + FOOTPRINT - 1 - x);
+            default -> cursor.set(site.x() + x, y, site.z() + z);
+        };
+    }
+
+    private static void place(WorldGenLevel level, Site site, BlockPos.MutableBlockPos cursor,
+                              int x, int y, int z, BlockState state) {
+        level.setBlock(mapped(site, cursor, x, y, z), state, 2);
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortLibraryWriting.java

@@ -0,0 +1,26 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+/** Written pages for library Age-only loot, kept outside the legacy backend index codec. */
+final class PortLibraryWriting extends SavedData {
+    static final Codec<PortLibraryWriting> CODEC = Codec.unboundedMap(Identifier.CODEC, Identifier.CODEC.listOf())
+            .fieldOf("ages").codec().xmap(PortLibraryWriting::new, data -> Map.copyOf(data.pages));
+    static final SavedDataType<PortLibraryWriting> TYPE = new SavedDataType<>(
+            Identifier.fromNamespaceAndPath("rivencraft", "library_writing"), () -> new PortLibraryWriting(Map.of()), CODEC);
+    private final Map<Identifier, List<Identifier>> pages = new HashMap<>();
+    private PortLibraryWriting(Map<Identifier, List<Identifier>> pages) { pages.forEach((id, list) -> this.pages.put(id, List.copyOf(list))); }
+    static PortLibraryWriting get(MinecraftServer server) { return server.overworld().getDataStorage().computeIfAbsent(TYPE); }
+    List<Identifier> symbols(Identifier id) { return pages.getOrDefault(id, List.of()); }
+    void put(Identifier id, List<Identifier> symbols) {
+        if (symbols.isEmpty()) pages.remove(id); else pages.put(id, List.copyOf(symbols));
+        setDirty();
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortLighting.java

@@ -0,0 +1,52 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.serialization.Codec;
+import java.util.Locale;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.Level;
+
+/** Authored lighting choices using statically registered, client-synchronized types. */
+public enum PortLighting {
+    NORMAL, DARK, BRIGHT;
+
+    public static final Codec<PortLighting> CODEC = Codec.STRING.xmap(
+            name -> valueOf(name.toUpperCase(Locale.ROOT)), mode -> mode.name().toLowerCase(Locale.ROOT));
+
+    public static PortLighting forPage(Identifier page) {
+        if (!page.getNamespace().equals(Rivencraft.MOD_ID)) return null;
+        return switch (page.getPath()) {
+            case "lighting/normal" -> NORMAL;
+            case "lighting/dark" -> DARK;
+            case "lighting/bright" -> BRIGHT;
+            default -> null;
+        };
+    }
+
+    public static boolean isBright(Level level) {
+        return level.dimensionTypeRegistration().unwrapKey().map(key -> {
+            Identifier id = key.identifier();
+            return id.getNamespace().equals(Rivencraft.MOD_ID)
+                    && (id.getPath().equals("age_bright") || id.getPath().equals("age_cave_bright")
+                        || id.getPath().startsWith("age_bright_sky_")
+                        || id.getPath().startsWith("age_cave_bright_sky_"));
+        }).orElse(false);
+    }
+
+    Holder<DimensionType> dimensionType(MinecraftServer server, PortAgeTerrain terrain,
+                                       Holder<DimensionType> overworldType, PortSkyStyle sky) {
+        boolean cave = terrain == PortAgeTerrain.CAVE;
+        if (this == NORMAL && !cave && sky == PortSkyStyle.OVERWORLD) return overworldType;
+        String variant = this == BRIGHT ? (cave ? "age_cave_bright" : "age_bright")
+                : this == DARK || cave ? "age_dark" : "age_normal";
+        if (sky != PortSkyStyle.OVERWORLD) variant += "_sky_" + sky.name().toLowerCase(Locale.ROOT);
+        return server.registryAccess().lookupOrThrow(Registries.DIMENSION_TYPE).getOrThrow(
+                ResourceKey.create(Registries.DIMENSION_TYPE,
+                        Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, variant)));
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortMeteorProvider.java

@@ -0,0 +1,133 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.WeakHashMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.particles.ParticleTypes;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.neoforge.event.level.LevelEvent;
+import net.neoforged.neoforge.event.server.ServerStoppingEvent;
+import net.neoforged.neoforge.event.tick.LevelTickEvent;
+
+/** The 1.21.1 meteor's short particle descent and bounded impact, without a new entity. */
+@EventBusSubscriber(modid = Rivencraft.MOD_ID)
+public final class PortMeteorProvider {
+    public static final Identifier METEORS = Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "meteors");
+    private static final int METEOR_FLIGHT_TICKS = 30;
+    private static final int MAX_ACTIVE_AGES = 16;
+    private static final Map<ServerLevel, Meteor> ACTIVE = new WeakHashMap<>();
+    private PortMeteorProvider() {}
+    public static void register() {
+        PortInstabilityRuntime.register(METEORS, false, (context, id, level) -> {
+            if (PortInstabilityRuntime.isAge(context.level())) scheduleMeteor(context, level, false);
+        });
+    }
+    static void tickPlanned(ServerLevel level, PortInstabilityData.Age age, long tick,
+                            List<PortInstabilityPlan.ProviderLevel> providers) {
+        var card = providers.stream().filter(provider -> provider.id().equals(METEORS)).findFirst();
+        if (card.isEmpty() || !PortInstabilityConfig.meteorEnabled()) return;
+        var chunks = PortHazardProviders.loadedChunksNearPlayers(level, PortInstabilityConfig.hazardsMaxChunks());
+        if (!chunks.isEmpty()) PortInstabilityRuntime.invoke(new PortInstabilityRuntime.Context(level, age, chunks,
+                tick, new PortInstabilityRuntime.Budget(1)), METEORS, card.get().level());
+    }
+    /** Skip the chance roll only; retain per-Age policy, loading, active-flight and cooldown checks. */
+    public static int pulseForTesting(ServerPlayer player) {
+        ServerLevel level = player.level();
+        if (!PortInstabilityRuntime.isAge(level)) return -1;
+        var age = PortInstabilityData.get(level.getServer()).age(level);
+        if (!PortInstabilityConfig.instabilityEnabled() || !PortInstabilityConfig.meteorEnabled()
+                || !age.enabled() || !PortInstabilityConfig.instabilityProviderEnabled(METEORS)) return 0;
+        var chunks = PortHazardProviders.loadedChunksNearPlayers(level, 16);
+        if (chunks.isEmpty()) return 0;
+        return scheduleMeteor(new PortInstabilityRuntime.Context(level, age, chunks,
+                level.getServer().getTickCount(), new PortInstabilityRuntime.Budget(1)), 1, true) ? 1 : 0;
+    }
+
+    private static boolean scheduleMeteor(PortInstabilityRuntime.Context context, int effectiveLevel, boolean force) {
+        if (!PortInstabilityConfig.meteorEnabled() || ACTIVE.containsKey(context.level())
+                || ACTIVE.size() >= MAX_ACTIVE_AGES) return false;
+        PortHazardSavedData data = PortHazardSavedData.get(context.level());
+        long gameTime = context.level().getGameTime();
+        if (!data.meteorReady(gameTime, 200)) return false;
+        Random random = new Random(context.age().seed() ^ data.nextAttempt() * 0xD1B54A32D192ED03L
+                ^ METEORS.hashCode());
+        if (!force && random.nextDouble() >= PortHazardProviders.legacyChance(context.loadedChunks().size(),
+                PortInstabilityConfig.instabilityCooldown(), effectiveLevel, 50000)) return false;
+        int start = random.nextInt(context.loadedChunks().size());
+        for (int offset = 0; offset < Math.min(16, context.loadedChunks().size()); offset++) {
+            ChunkPos chunk = context.loadedChunks().get((start + offset) % context.loadedChunks().size());
+            int x = chunk.getMinBlockX() + 6 + random.nextInt(4);
+            int z = chunk.getMinBlockZ() + 6 + random.nextInt(4);
+            int surfaceY = context.level().getHeight(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, x, z);
+            BlockPos impact = new BlockPos(x, surfaceY, z);
+            if (surfaceY >= context.level().getMaxY() - 8
+                    || !PortHazardProviders.safeTarget(context, impact, 8)) continue;
+            if (!context.budget().claim()) return false;
+            int startY = Math.min(context.level().getMaxY() - 2, surfaceY + 48);
+            data.recordMeteor(gameTime);
+            ACTIVE.put(context.level(), new Meteor(chunk, impact, startY, METEOR_FLIGHT_TICKS));
+            context.level().playSound(null, impact, Rivencraft.METEOR_ROAR.get(), SoundSource.WEATHER, 2.0F, 1.0F);
+            context.budget().recordApplied();
+            return true;
+        }
+        return false;
+    }
+
+    @SubscribeEvent
+    public static void onLevelTickPost(LevelTickEvent.Post event) {
+        if (!(event.getLevel() instanceof ServerLevel level)) return;
+        Meteor meteor = ACTIVE.get(level);
+        if (meteor == null) return;
+        if (!PortInstabilityConfig.instabilityEnabled() || !PortInstabilityConfig.meteorEnabled()
+                || !PortInstabilityRuntime.isAge(level)
+                || level.players().isEmpty()
+                || level.getChunkSource().getChunkNow(meteor.chunk().x(), meteor.chunk().z()) == null) {
+            ACTIVE.remove(level);
+            return;
+        }
+        var age = PortInstabilityData.get(level.getServer()).age(level);
+        if (!age.enabled()
+                || !PortInstabilityConfig.instabilityProviderEnabled(METEORS)) {
+            ACTIVE.remove(level);
+            return;
+        }
+        int remaining = meteor.remaining() - 1;
+        if (remaining <= 0) {
+            ACTIVE.remove(level); // clear before impact so an exception cannot replay it
+            PortHazardProviders.explodeBounded(level, age, meteor.chunk(), meteor.impact(),
+                    PortInstabilityConfig.meteorBlockDamage(), PortInstabilityConfig.meteorPlayerDamage(),
+                    PortInstabilityConfig.meteorFire(), PortInstabilityConfig.meteorMaxBlocks(),
+                    PortInstabilityConfig.meteorMaxEntities(), PortInstabilityConfig.meteorMaxDamage(), 3);
+            return;
+        }
+        double progress = 1.0 - remaining / (double) METEOR_FLIGHT_TICKS;
+        double y = meteor.startY() + (meteor.impact().getY() - meteor.startY()) * progress;
+        double x = meteor.impact().getX() + 0.5 + (1.0 - progress) * 2.0;
+        double z = meteor.impact().getZ() + 0.5 + (1.0 - progress) * 2.0;
+        level.sendParticles(ParticleTypes.FLAME, x, y, z, 5, 0.25, 0.25, 0.25, 0.01);
+        level.sendParticles(ParticleTypes.LARGE_SMOKE, x, y, z, 2, 0.3, 0.3, 0.3, 0.02);
+        ACTIVE.put(level, new Meteor(meteor.chunk(), meteor.impact(), meteor.startY(), remaining));
+    }
+
+    @SubscribeEvent
+    public static void onServerStopping(ServerStoppingEvent event) {
+        ACTIVE.clear(); // an interrupted descent is cancelled, never replayed after restart
+    }
+
+    @SubscribeEvent
+    public static void onLevelUnload(LevelEvent.Unload event) {
+        if (event.getLevel() instanceof ServerLevel level) ACTIVE.remove(level);
+    }
+
+    private record Meteor(ChunkPos chunk, BlockPos impact, int startY, int remaining) {}
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortNotebookProbe.java

@@ -0,0 +1,94 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.item.CollationFolderItem;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.menu.NotebookMenu;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.RegistryOps;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.Container;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.inventory.ContainerInput;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Blocks;
+
+/** Disposable-world menu, ownership, codec and chest-persistence fixtures. */
+final class PortNotebookProbe {
+    private static final BlockPos CHEST = new BlockPos(0, 64, 0);
+    private PortNotebookProbe() {}
+
+    static void create(ServerLevel level) {
+        PortAgeTravel.findLanding(level);
+        level.setBlock(CHEST, Blocks.CHEST.defaultBlockState(), 3);
+        Container chest = (Container) level.getBlockEntity(CHEST);
+        var player = net.neoforged.neoforge.common.util.FakePlayerFactory.get(level,
+                new com.mojang.authlib.GameProfile(java.util.UUID.fromString("1043b9f3-f348-4a73-b585-e0de13fd5c27"), "RivenNotebookProbe"));
+        int output = 0;
+        try {
+            for (boolean folder : List.of(false, true)) for (var hand : InteractionHand.values()) {
+                player.getInventory().clearContent();
+                player.getInventory().setSelectedSlot(0);
+                ItemStack collection = new ItemStack(folder ? Rivencraft.COLLATION_FOLDER.get() : Rivencraft.NOTEBOOK.get());
+                player.setItemInHand(hand, collection);
+                var menu = new NotebookMenu(1, player.getInventory(), hand);
+                int capacity = CollationFolderItem.capacity(collection);
+                if (!menu.stillValid(player) || menu.pageCapacity() != capacity
+                        || menu.getSlot(0).mayPlace(PageItem.createLinkPanelPage())
+                        || menu.getSlot(0).mayPlace(new ItemStack(net.minecraft.world.item.Items.DIAMOND)))
+                    throw new IllegalStateException("Notebook capacity/page acceptance regression");
+                ItemStack page = PageItem.createSymbolPage(Identifier.fromNamespaceAndPath("rivencraft", "terrain/flat"));
+                player.getInventory().setItem(9, page.copyWithCount(3));
+                menu.clicked(NotebookMenu.NOTEBOOK_SLOTS, 0, ContainerInput.QUICK_MOVE, player);
+                if (!player.getInventory().getItem(9).isEmpty() || contents(collection).pageCount() != 3)
+                    throw new IllegalStateException("Notebook shift insertion regression");
+                for (int i = 0; i < 3; i++) menu.clicked(i, 0, ContainerInput.QUICK_MOVE, player);
+                if (contents(collection).pageCount() != 0) throw new IllegalStateException("Notebook shift extraction regression");
+                menu.getSlot(capacity - 1).set(page.copy());
+                if (contents(collection).pageCount() != 1 || !contents(collection).pages().get(0).isEmpty()
+                        || contents(collection).pages().get(capacity - 1).isEmpty())
+                    throw new IllegalStateException("Notebook sparse position regression");
+                if (!menu.clickMenuButton(player, NotebookMenu.MOVE_PREVIOUS_BASE + capacity - 1)
+                        || !contents(collection).pages().get(capacity - 1).isEmpty())
+                    throw new IllegalStateException("Notebook page movement regression");
+                if (folder && menu.getSlot(capacity).mayPlace(page))
+                    throw new IllegalStateException("Folder exceeded 27 positions");
+                menu.clicked(NotebookMenu.NOTEBOOK_SLOTS + 27, 0, ContainerInput.PICKUP, player);
+                if (player.getItemInHand(hand) != collection || !menu.getCarried().isEmpty())
+                    throw new IllegalStateException("Notebook active item was movable");
+                var ops = RegistryOps.create(com.mojang.serialization.JsonOps.INSTANCE, level.registryAccess());
+                var encoded = NotebookContents.CODEC.encodeStart(ops, contents(collection)).getOrThrow();
+                var decoded = NotebookContents.CODEC.parse(ops, encoded).getOrThrow();
+                var buffer = new RegistryFriendlyByteBuf(io.netty.buffer.Unpooled.buffer(), level.registryAccess());
+                try {
+                    NotebookContents.STREAM_CODEC.encode(buffer, decoded);
+                    decoded = NotebookContents.STREAM_CODEC.decode(buffer);
+                    if (decoded.pageCount() != 1 || decoded.pages().get(capacity - 2).isEmpty())
+                        throw new IllegalStateException("Notebook save/network codec regression");
+                } finally { buffer.release(); }
+                chest.setItem(output++, collection.copy());
+                player.setItemInHand(hand, ItemStack.EMPTY);
+            }
+        } finally { player.getInventory().clearContent(); }
+        verify(level);
+    }
+
+    private static NotebookContents contents(ItemStack stack) {
+        return stack.getOrDefault(Rivencraft.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY);
+    }
+
+    static void verify(ServerLevel level) {
+        if (!(level.getBlockEntity(CHEST) instanceof Container chest)) throw new IllegalStateException("Fixture chest missing");
+        for (int i = 0; i < 4; i++) {
+            var collection = chest.getItem(i);
+            int capacity = i < 2 ? 252 : 27;
+            if (CollationFolderItem.capacity(collection) != capacity || contents(collection).pageCount() != 1
+                    || contents(collection).pages().get(capacity - 2).isEmpty())
+                throw new IllegalStateException("Notebook chest persistence regression: " + i);
+        }
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortObelisksFeature.java

@@ -0,0 +1,91 @@
+package net.dnorberg.rivencraft.age;
+
+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.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/** 26.3 port of Rivencraft 1.21.1's Legacy-style 4×4 plinth and 2×12×2 shaft. */
+final class PortObelisksFeature {
+    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 PortObelisksFeature() {}
+
+    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, BlockState material, int occurrence) {
+        Site site = site(ageSeed, chunk.getPos(), occurrence);
+        if (site == null) return;
+        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.getMinY() + 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.getMaxY()) 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;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortProgressionPlayer.java

@@ -0,0 +1,25 @@
+package net.dnorberg.rivencraft.age;
+
+import com.mojang.authlib.GameProfile;
+import net.minecraft.server.PlayerAdvancements;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.datafix.DataFixers;
+import net.minecraft.world.level.storage.LevelResource;
+import net.neoforged.neoforge.common.util.FakePlayer;
+
+/** FakePlayer normally discards all advancement progress; fixtures need vanilla tracking. */
+final class PortProgressionPlayer extends FakePlayer {
+    private PlayerAdvancements progress;
+
+    PortProgressionPlayer(ServerLevel level, GameProfile profile) { super(level, profile); }
+
+    @Override public PlayerAdvancements getAdvancements() {
+        if (progress == null) {
+            var server = level().getServer();
+            progress = new PlayerAdvancements(DataFixers.getDataFixer(), server.getPlayerList(),
+                    server.getAdvancements(), server.getWorldPath(LevelResource.PLAYER_ADVANCEMENTS_DIR)
+                            .resolve(getUUID() + ".json"), this);
+        }
+        return progress;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortProgressionProbe.java

@@ -0,0 +1,101 @@
+package net.dnorberg.rivencraft.age;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.advancement.ProgressionAdvancements;
+import net.dnorberg.rivencraft.block.entity.InkMixerBlockEntity;
+import net.dnorberg.rivencraft.menu.InkMixerMenu;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.inventory.ContainerInput;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+/** Disposable operator fixture for loaded advancement data and committed action awards. */
+final class PortProgressionProbe {
+    /** Operator-fixture assertion; deliberately requires the real loaded advancement. */
+    static boolean isComplete(net.minecraft.server.level.ServerPlayer player, String path) {
+        var advancement = player.level().getServer().getAdvancements().get(
+                net.minecraft.resources.Identifier.fromNamespaceAndPath(Rivencraft.MOD_ID, "progression/" + path));
+        if (advancement == null) throw new IllegalStateException("Missing progression advancement: " + path);
+        return player.getAdvancements().getOrStartProgress(advancement).isDone();
+    }
+
+
+    static void recipeDiscovery(ServerLevel level) {
+        var materials = java.util.Map.of(
+                "ink_vial", Items.DYE.black(),
+                "ink_mixer", Items.GLASS_BOTTLE,
+                "book_binder", Items.IRON_INGOT,
+                "crystal_block", Rivencraft.CRYSTAL_SHARD.get(),
+                "notebook", Items.LEATHER,
+                "writing_desk", Items.FEATHER);
+        for (var entry : materials.entrySet()) {
+            var id = net.minecraft.resources.Identifier.fromNamespaceAndPath("rivencraft", entry.getKey());
+            var key = net.minecraft.resources.ResourceKey.create(net.minecraft.core.registries.Registries.RECIPE, id);
+            var player = new PortProgressionPlayer(level, new com.mojang.authlib.GameProfile(
+                    java.util.UUID.nameUUIDFromBytes(id.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8)),
+                    "RivenRecipe"));
+            var advancement = level.getServer().getAdvancements().get(
+                    net.minecraft.resources.Identifier.fromNamespaceAndPath("rivencraft", "recipes/misc/" + entry.getKey()));
+            if (advancement == null || level.getServer().getRecipeManager().byKey(key).isEmpty())
+                throw new IllegalStateException("Missing recipe/discovery data: " + id);
+            var progress = player.getAdvancements();
+            net.minecraft.advancements.triggers.CriteriaTriggers.INVENTORY_CHANGED.trigger(player,
+                    player.getInventory(), new ItemStack(Items.COBBLESTONE));
+            if (player.getRecipeBook().contains(key))
+                throw new IllegalStateException("Wrong material unlocked " + id);
+            var material = new ItemStack(entry.getValue());
+            player.getInventory().setItem(0, material);
+            net.minecraft.advancements.triggers.CriteriaTriggers.INVENTORY_CHANGED.trigger(player, player.getInventory(), material);
+            if (!player.getRecipeBook().contains(key) || !progress.getOrStartProgress(advancement).isDone())
+                throw new IllegalStateException("Material did not unlock " + id);
+            // The second criterion supports /recipe give without first obtaining its material.
+            var other = new PortProgressionPlayer(level, new com.mojang.authlib.GameProfile(
+                    java.util.UUID.randomUUID(), "RivenRecipeGive"));
+            if (other.getRecipeBook().contains(key)) throw new IllegalStateException("Recipe leaked between players");
+            other.awardRecipes(java.util.List.of(level.getServer().getRecipeManager().byKey(key).orElseThrow()));
+            if (!other.getAdvancements().getOrStartProgress(advancement).isDone())
+                throw new IllegalStateException("Recipe unlock criterion did not complete " + id);
+        }
+    }
+
+    static void run(ServerLevel level) {
+        var player = new PortProgressionPlayer(level,
+                new com.mojang.authlib.GameProfile(java.util.UUID.fromString("b428c3ef-57a6-43dc-95e8-441b6a171107"), "RivenProgression"));
+        var pos = new BlockPos(4, 64, 0);
+        player.setPos(4.5, 64, 2.5);
+        level.setBlock(pos, Rivencraft.INK_MIXER.get().defaultBlockState(), 3);
+        var mixer = (InkMixerBlockEntity) level.getBlockEntity(pos);
+        try {
+            // Every tree node must decode; portal advancement waits for its missing item/feature port.
+            for (String path : new String[]{"root", "page", "linking_book", "link_panel", "copy_page", "bind_age", "enter_age"})
+                if (isComplete(player, path))
+                    throw new IllegalStateException("Fixture requires fresh player advancement data");
+            var menu = new InkMixerMenu(1, player.getInventory(), mixer);
+            menu.clicked(InkMixerMenu.RESULT, 0, ContainerInput.PICKUP, player);
+            if (isComplete(player, "link_panel"))
+                throw new IllegalStateException("Empty Mixer awarded progression");
+            mixer.setItem(InkMixerBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
+            mixer.setItem(InkMixerBlockEntity.INK, new ItemStack(Rivencraft.INK_VIAL.get()));
+            menu.broadcastChanges();
+            if (isComplete(player, "link_panel"))
+                throw new IllegalStateException("Mixer preview awarded progression");
+            menu.clicked(InkMixerMenu.RESULT, 0, ContainerInput.PICKUP, player);
+            if (!isComplete(player, "link_panel"))
+                throw new IllegalStateException("Mixer pickup did not award progression");
+            menu.setCarried(ItemStack.EMPTY);
+            var advancement = level.getServer().getAdvancements().get(
+                    net.minecraft.resources.Identifier.fromNamespaceAndPath("rivencraft", "progression/link_panel"));
+            player.getAdvancements().revoke(advancement, "completed");
+            menu.quickMoveStack(player, InkMixerMenu.RESULT);
+            if (!isComplete(player, "link_panel"))
+                throw new IllegalStateException("Mixer shift pickup did not award progression");
+            ProgressionAdvancements.awardAgeTravel(player);
+            if (!isComplete(player, "enter_age"))
+                throw new IllegalStateException("Registered Age did not award entry");
+        } finally {
+            player.getInventory().clearContent();
+            level.removeBlock(pos, false);
+        }
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortRandomAgeSelection.java

@@ -0,0 +1,92 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Random;
+import net.dnorberg.rivencraft.writing.PortRegistryPages;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.MinecraftServer;
+
+/** Seed-frozen terrain and biome choices for a book with no authored symbols. */
+public final class PortRandomAgeSelection {
+    private PortRandomAgeSelection() {}
+
+    public record Selection(PortAgeTerrain terrain, PortBiomePlan biomes) {}
+
+    public static Selection select(MinecraftServer server, long seed) {
+        // Match the 1.21.1 Legacy-rank choices: Standard and Flat are common;
+        // the other terrain families are rarer. The sorted order is deliberate.
+        PortAgeTerrain terrain = terrain(seed);
+        if (terrain == PortAgeTerrain.VOID)
+            return new Selection(terrain, new PortBiomePlan(PortBiomePlan.Distribution.SINGLE,
+                    List.of(Identifier.withDefaultNamespace("the_void"))));
+
+        PortBiomePlan.Distribution distribution = distribution(seed);
+        List<Identifier> eligible = eligibleBiomes(server, terrain);
+        if (eligible.size() < 2 && distribution != PortBiomePlan.Distribution.NATIVE)
+            distribution = PortBiomePlan.Distribution.SINGLE;
+        if (distribution == PortBiomePlan.Distribution.NATIVE)
+            return new Selection(terrain, new PortBiomePlan(distribution,
+                    terrain == PortAgeTerrain.CAVE ? eligible : List.of()));
+
+        int count = distribution == PortBiomePlan.Distribution.SINGLE ? 1 : 2;
+        if (count > 1) {
+            Random countRandom = new Random(seed ^ 0x42494F4D45434F55L);
+            while (count < eligible.size() && countRandom.nextInt(3) != 0) count++;
+        }
+        List<Identifier> shuffled = new ArrayList<>(eligible);
+        Collections.shuffle(shuffled, new Random(seed ^ 0x42494F4D45504F4FL));
+        return new Selection(terrain, new PortBiomePlan(distribution, shuffled.subList(0, count)));
+    }
+
+    public static List<PortAgeTerrain> terrains() {
+        return List.of(PortAgeTerrain.AMPLIFIED, PortAgeTerrain.CAVE, PortAgeTerrain.FLAT,
+                PortAgeTerrain.ISLAND, PortAgeTerrain.STANDARD, PortAgeTerrain.VOID);
+    }
+
+    public static PortAgeTerrain terrain(long seed) {
+        return weighted(new Random(seed ^ 0x5445525241494E4CL), terrains(), new int[]{1, 1, 5, 1, 6, 1});
+    }
+
+    /** First AgeTraits draw in 1.21.1; shared by random and partly authored Ages. */
+    public static PortBiomePlan.Distribution distribution(long seed) {
+        return weighted(new Random(seed ^ 0x524956454E435241L),
+                List.of(PortBiomePlan.Distribution.NATIVE, PortBiomePlan.Distribution.SINGLE,
+                        PortBiomePlan.Distribution.MEDIUM, PortBiomePlan.Distribution.TILED,
+                        PortBiomePlan.Distribution.GRID, PortBiomePlan.Distribution.TINY,
+                        PortBiomePlan.Distribution.SMALL, PortBiomePlan.Distribution.LARGE,
+                        PortBiomePlan.Distribution.HUGE),
+                new int[]{3, 3, 3, 1, 1, 1, 1, 1, 1});
+    }
+
+    public static List<Identifier> eligibleBiomes(MinecraftServer server, PortAgeTerrain terrain) {
+        if (terrain == PortAgeTerrain.VOID) return List.of(Identifier.withDefaultNamespace("the_void"));
+        if (terrain == PortAgeTerrain.CAVE) {
+            return caveBiomes(server.registryAccess());
+        }
+        List<Identifier> surface = server.overworld().getChunkSource().getGenerator().getBiomeSource()
+                .possibleBiomes().stream().flatMap(holder -> holder.unwrapKey().stream())
+                .map(key -> key.identifier()).distinct().sorted(Comparator.naturalOrder()).toList();
+        return surface.isEmpty() ? List.of(Identifier.withDefaultNamespace("plains")) : surface;
+    }
+
+    public static List<Identifier> caveBiomes(net.minecraft.core.HolderLookup.Provider registries) {
+        var caves = registries.lookupOrThrow(Registries.BIOME).listElements()
+                .filter(PortRegistryPages::isCaveBiome).map(holder -> holder.key().identifier()).sorted().toList();
+        return caves.isEmpty() ? List.of(Identifier.withDefaultNamespace("lush_caves")) : caves;
+    }
+
+    static <T> T weighted(Random random, List<T> choices, int[] weights) {
+        int total = 0;
+        for (int weight : weights) total += weight;
+        int ticket = random.nextInt(total);
+        for (int index = 0; index < choices.size(); index++) {
+            ticket -= weights[index];
+            if (ticket < 0) return choices.get(index);
+        }
+        throw new IllegalStateException("Random Age ticket was not consumed");
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortRandomFeatureSelection.java

@@ -0,0 +1,85 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import net.dnorberg.rivencraft.writing.PortAuthoredWriting;
+import net.dnorberg.rivencraft.writing.PortRegistryPages;
+import net.minecraft.resources.Identifier;
+
+/** Frozen page-free material features and rare formations from 1.21.1. */
+public final class PortRandomFeatureSelection {
+    private PortRandomFeatureSelection() {}
+    public record Selection(PortRockPlan rocks, PortLakePlan lakes, PortTerrainFeaturePlan terrain, int dungeons) {}
+
+    public static Selection select(net.minecraft.server.MinecraftServer server, long seed,
+                                    PortAgeTerrain terrain, PortBiomePlan biomes) {
+        var base = select(seed, terrain);
+        var structures = PortRandomStructureSelection.select(server, seed, terrain, biomes);
+        var plan = base.terrain();
+        plan = plan == null ? new PortTerrainFeaturePlan(List.of(), false, 0, false, structures.structures(), List.of(), true)
+                    : new PortTerrainFeaturePlan(plan.choices(), plan.skylands(), plan.denseOres(), plan.starFissures(),
+                            structures.structures(), plan.carvers(), true);
+        return new Selection(base.rocks(), base.lakes(), plan, structures.dungeons());
+    }
+
+    public static Selection select(long seed, PortAgeTerrain terrain) {
+        var random = new Random(seed ^ 0x4D4154455249414CL);
+        int count = random.nextInt(3);
+        var terrainPage = id("terrain/" + terrain.name().toLowerCase(java.util.Locale.ROOT));
+        var candidates = new ArrayList<PortRankedChoice.Option<Identifier>>();
+        for (String name : List.of("rocks", "floating_islands", "tendrils", "spheres", "spikes", "obelisks",
+                "surface_lakes", "deep_lakes", "lava_lakes")) {
+            var page = id("feature/" + name);
+            if (PortAuthoredWriting.supports(List.of(terrainPage, page)))
+                candidates.add(new PortRankedChoice.Option<>(page, rank(name)));
+        }
+        var pages = new ArrayList<Identifier>();
+        pages.add(terrainPage);
+        List<Identifier> solids = PortRegistryPages.solidMaterialIds(), fluids = PortRegistryPages.fluidMaterialIds();
+        for (int selected = 0; selected < count && !candidates.isEmpty();) {
+            Identifier feature = PortRankedChoice.choose(random, candidates);
+            candidates.removeIf(option -> option.value().equals(feature));
+            var materials = PortLakePlan.isLake(feature) ? fluids : solids;
+            if (materials.isEmpty()) continue;
+            pages.add(PortRegistryPages.blockPageId(materials.get(random.nextInt(materials.size()))));
+            pages.add(feature);
+            selected++;
+        }
+        if (terrain != PortAgeTerrain.FLAT && terrain != PortAgeTerrain.VOID
+                && Math.floorMod(mix(seed ^ 0x534B594C414E4453L), 8) == 0)
+            pages.add(PortTerrainFeaturePlan.SKYLANDS);
+        if (terrain != PortAgeTerrain.CAVE && terrain != PortAgeTerrain.VOID && random.nextInt(10) == 0)
+            pages.add(PortTerrainFeaturePlan.CRYSTAL_FORMATIONS);
+        if (randomStarFissure(seed)) pages.add(PortTerrainFeaturePlan.STAR_FISSURES);
+        return new Selection(PortAuthoredWriting.rockPlan(pages, seed), PortAuthoredWriting.lakePlan(pages, seed),
+                PortAuthoredWriting.terrainFeaturePlan(pages, seed), 0);
+    }
+
+    private static int rank(String name) {
+        return switch (name) {
+            case "surface_lakes", "deep_lakes" -> 1;
+            case "lava_lakes" -> 2;
+            case "spheres", "spikes", "obelisks" -> 3;
+            default -> 4;
+        };
+    }
+
+    private static boolean randomStarFissure(long seed) {
+        var random = new Random(mix(seed ^ 0x535441524752414DL));
+        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 Identifier id(String path) { return Identifier.fromNamespaceAndPath("rivencraft", path); }
+    private static long mix(long value) {
+        value = (value ^ value >>> 30) * 0xBF58476D1CE4E5B9L;
+        value = (value ^ value >>> 27) * 0x94D049BB133111EBL;
+        return value ^ value >>> 31;
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortRandomStructureSelection.java

@@ -0,0 +1,69 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.level.dimension.LevelStem;
+
+/** Creation-only structure completion, adapted from 1.21.1 AgeStructureSelection. */
+public final class PortRandomStructureSelection {
+    private static final Identifier DUNGEONS = page("dungeons");
+    private PortRandomStructureSelection() {}
+    public record Selection(int dungeons, List<Identifier> structures) {
+        public Selection { structures = List.copyOf(structures); }
+    }
+
+    public static Selection select(MinecraftServer server, long seed, PortAgeTerrain terrain, PortBiomePlan plan) {
+        Set<Identifier> biomes = actualBiomes(server, terrain, plan);
+        var eligible = new ArrayList<PortRankedChoice.Option<Identifier>>();
+        for (String name : List.of("dungeons", "mineshafts", "nether_fortresses", "strongholds", "villages",
+                "trial_chambers", "bastions", "buried_treasure", "shipwrecks", "ocean_ruins", "pillager_outposts",
+                "ruined_portals", "nether_fossils", "ancient_cities", "trail_ruins", "abandoned_camps")) {
+            Identifier feature = page(name);
+            boolean allowed = feature.equals(DUNGEONS)
+                    ? net.dnorberg.rivencraft.writing.PortAuthoredWriting.supports(List.of(
+                            Identifier.fromNamespaceAndPath("rivencraft", "terrain/" + terrain.name().toLowerCase(java.util.Locale.ROOT)), feature))
+                        && server.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE)
+                            .get(ResourceKey.create(Registries.PLACED_FEATURE,
+                                    Identifier.fromNamespaceAndPath("rivencraft", "dungeons"))).isPresent()
+                    : PortStructurePages.randomEligible(feature, terrain, biomes, server.registryAccess());
+            if (allowed) eligible.add(new PortRankedChoice.Option<>(feature, rank(name)));
+        }
+        var random = new Random(seed ^ 0x5354525543545552L);
+        int count = random.nextInt(3), dungeons = 0;
+        var structures = new ArrayList<Identifier>();
+        for (int selected = 0; selected < count && !eligible.isEmpty(); selected++) {
+            var feature = PortRankedChoice.choose(random, eligible);
+            if (feature.equals(DUNGEONS)) dungeons++;
+            else structures.add(feature);
+            eligible.removeIf(option -> option.value().equals(feature));
+        }
+        return new Selection(dungeons, structures);
+    }
+
+    private static Set<Identifier> actualBiomes(MinecraftServer server, PortAgeTerrain terrain, PortBiomePlan plan) {
+        if (plan != null && !plan.biomes().isEmpty())
+            return Set.copyOf(plan.biomes());
+        if (terrain == PortAgeTerrain.FLAT) return Set.of(Identifier.withDefaultNamespace("plains"));
+        if (terrain == PortAgeTerrain.VOID) return Set.of(Identifier.withDefaultNamespace("the_void"));
+        if (terrain == PortAgeTerrain.CAVE) return Set.of(Identifier.withDefaultNamespace("lush_caves"));
+        return server.registryAccess().lookupOrThrow(Registries.LEVEL_STEM).getOrThrow(LevelStem.OVERWORLD)
+                .value().generator().getBiomeSource().possibleBiomes().stream()
+                .flatMap(holder -> holder.unwrapKey().stream()).map(key -> key.identifier())
+                .collect(java.util.stream.Collectors.toUnmodifiableSet());
+    }
+
+    private static int rank(String name) {
+        return switch (name) {
+            case "villages", "strongholds", "mineshafts" -> 1;
+            case "dungeons", "nether_fortresses" -> 2;
+            default -> 3;
+        };
+    }
+    private static Identifier page(String name) { return Identifier.fromNamespaceAndPath("rivencraft", "feature/" + name); }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortRankedChoice.java

@@ -0,0 +1,36 @@
+package net.dnorberg.rivencraft.age;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+
+/** The 1.21.1 LegacyRankChoice rule, retained for seeded grammar completion. */
+final class PortRankedChoice {
+    private PortRankedChoice() {}
+    record Option<T>(T value, int rank) {}
+
+    static <T> T choose(Random random, List<Option<T>> options) {
+        if (options.isEmpty()) throw new IllegalArgumentException("No ranked choices");
+        var counts = new HashMap<Integer, Integer>();
+        int highest = 0;
+        for (var option : options) {
+            counts.merge(option.rank(), 1, Integer::sum);
+            highest = Math.max(highest, option.rank());
+        }
+        var weights = new HashMap<Integer, Integer>();
+        int weight = 1, 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 ticket = random.nextInt(options.stream().mapToInt(option -> weights.get(option.rank())).sum());
+        for (var option : options) {
+            ticket -= weights.get(option.rank());
+            if (ticket < 0) return option.value();
+        }
+        throw new IllegalStateException("Ranked choice ticket was not consumed");
+    }
+}

ports/mc263/src/main/java/net/dnorberg/rivencraft/age/PortReturnLinks.java

@@ -0,0 +1,48 @@
+package net.dnorberg.rivencraft.age;
+
+import net.dnorberg.rivencraft.PortConfig;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.item.LinkBookTarget;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.Prediction;
+import net.minecraft.world.item.ItemStack;
+
+/** Called only after successful Descriptive Book travel and its Disarm effect. */
+public final class PortReturnLinks {
+    private PortReturnLinks() {}
+
+    public static void afterSuccessfulTravel(ServerPlayer player, Identifier age, LinkBookTarget departure) {
+        var mode = PortConfig.RETURN_LINK_MODE.get();
+        if (mode == PortConfig.ReturnLinkMode.DISABLED) return;
+        var storage = player.level().getServer().overworld().getDataStorage();
+        boolean issue = shouldIssue(mode, storage.computeIfAbsent(PortAgeVisits.TYPE), age);
+        if (!issue) return;
+        ItemStack book = createBook(departure);
+        var source = player.level().getServer().getLevel(net.minecraft.resources.ResourceKey.create(
+                net.minecraft.core.registries.Registries.DIMENSION, departure.dimension()));
+        if (source != null) book.set(Rivencraft.LINK_DESTINATION_NAME.get(),
+                net.dnorberg.rivencraft.item.LinkingBookItem.destinationName(source));
+        if (!player.getInventory().add(book)) player.drop(book, false, Prediction.SERVER_ONLY);
+        // Persist the once-per-Age marker before the next arrival can issue another.
+        if (mode == PortConfig.ReturnLinkMode.ON_CREATION)
+            storage.saveAndJoin();
+    }
+
+    static boolean shouldIssue(PortConfig.ReturnLinkMode mode, PortAgeVisits visits, Identifier age) {
+        return switch (mode) {
+            case DISABLED -> false;
+            case ALWAYS -> true;
+            case ON_CREATION -> visits.markFirstVisit(age);
+        };
+    }
+
+    static ItemStack createBook(LinkBookTarget departure) {
+        ItemStack book = new ItemStack(Rivencraft.LINKING_BOOK.get());
+        book.set(Rivencraft.LINK_BOOK_TARGET.get(), departure);
+        book.set(DataComponents.CUSTOM_NAME, Component.translatable("item.rivencraft.linking_book.return"));
+        return book;
+    }
+}