@rpgm-tools/neo-angband-core 0.18.0 → 0.19.0

package/dist/session/game.js

@@ -17,10 +17,10 @@
  * ui-game.c:757-760: store_reset, seed_randart, seed_flavor (back-to-back),
  * then prepare_next_level generation.
  */
-import { loc } from "../loc.js";
+import { DDGRID, loc, locSum } from "../loc.js";
 import { MessageLog } from "../msg.js";
-import { SKILL, STAT_MAX } from "../player/types.js";
-import { EF, ELEM, HIST, OF, PF, RF, STAT, TMD } from "../generated/index.js";
+import { PN, SKILL, STAT_MAX } from "../player/types.js";
+import { EF, ELEM, HIST, MSG, OF, PF, RF, STAT, TMD } from "../generated/index.js";
 import { bindPlayer } from "../player/bind.js";
 import { generatePlayer, optionsInitCheat, flavorSetAllAware, } from "../player/birth.js";
 import { bonusChangeMessages, calcBonuses, calcHitpoints, toCombatState, toDefenderState, } from "../player/calcs.js";
@@ -28,15 +28,17 @@ import { playerBestDiggerDigging, playerBestDiggerWithClause, } from "../player/
 import { playerExpGain, playerKillExp } from "../player/exp.js";
 import { historyAdd, historyFindArtifact, historyLoseArtifact } from "../player/history.js";
 import { artifactHistoryName, historyStamp } from "../game/history.js";
-import { makePlayerSideEffects, makeIncCheckQueries } from "../game/player-side.js";
+import { makePlayerSideEffects, makeIncCheckHooks, makeIncCheckQueries, makeTimedNotifyQueries, } from "../game/player-side.js";
+import { ProjectionHandlerRegistry } from "../game/projection-handlers.js";
 import { makeTakeHitHooks } from "../game/take-hit-hooks.js";
 import { makeMonBlowEnv } from "../game/mon-side.js";
+import { BlowEffectRegistry, registerCoreBlowEffects, } from "../combat/mon-melee.js";
 import { adj_dex_safe } from "../player/calcs.js";
 import { processCurseTimeouts } from "../game/curse-tick.js";
 import { buildEffectContext } from "../game/effect-env.js";
 import { attachGameEnv } from "../game/effect-game-env.js";
 import { sourceMonster, sourceNone, sourcePlayer } from "../effects/interpreter.js";
-import { DEFAULT_GAME_CONSTANTS, addMonster, deleteMonster, placePlayer, squareMonster, updateMonsterDistances, } from "../game/context.js";
+import { DEFAULT_GAME_CONSTANTS, addMonster, deleteMonster, placePlayer, playerOfHas, squareMonster, updateMonsterDistances, } from "../game/context.js";
 import { Chunk } from "../world/chunk.js";
 import { chunkWriteTerrain } from "../gen/cave.js";
 import { FEAT, SQUARE } from "../generated/index.js";
@@ -57,11 +59,11 @@ import { registerItemHandlers } from "../game/effect-item.js";
 import { registerMeleeHandlers } from "../game/effect-melee.js";
 import { registerSummonHandlers } from "../game/effect-summon.js";
 import { registerDetectHandlers } from "../game/effect-detect.js";
-import { becomeAware, caveIlluminateKnown, caveKnown, newKnownMap, noteSpots, viewerStateOf, } from "../game/known.js";
+import { becomeAware, caveIlluminateKnown, caveKnown, newKnownMap, noteSpots, monsterLightSources, updateMon, viewerStateOf, } from "../game/known.js";
 import { updateView } from "../world/view.js";
 import { PY_EXERT, compactMonsters, isDaytime, playerOverExert } from "../game/world.js";
 import { restoreMonsters } from "../game/scheduler.js";
-import { newTargetState, targetSetMonster } from "../game/target.js";
+import { newTargetState, targetGet, targetOkay, targetSetMonster, } from "../game/target.js";
 import { getLore, loreCountU16, loreLearnFlagIfVisible, loreLearnSpellIfVisible, loreUpdate, } from "../mon/lore.js";
 import { monsterIsVisible } from "../mon/predicate.js";
 import { countMonsterRaces, multiplyMonster, pickAndPlaceDistantMonster, squareIsEmptyLive, wipeMonsterCounts, } from "../game/mon-place.js";
@@ -70,6 +72,7 @@ import { MonAllocTable } from "../mon/make.js";
 import { thrustAway } from "../game/thrust.js";
 import { basicPlayerActor } from "../game/project-cast.js";
 import { installMonsterCasting } from "../game/mon-ranged.js";
+import { polyRace, polymorphMonster } from "../game/poly.js";
 import { buildMonSpellHooks, buildFailRuneEnv } from "../game/mon-cast.js";
 import { installMonCommand } from "../game/mon-cmd.js";
 import { monsterChangeShape, monsterRevertShape } from "../game/mon-shape.js";
@@ -83,29 +86,36 @@ import { calcMana, calcSpells, cumberArmorFrom, playerSpellsInit, registerBookKi
 import { installSpellCommands, makeSpellChanceEnv } from "../game/spell-cmd.js";
 import { installRangedCommands } from "../game/ranged-cmd.js";
 import { markNoscore, NOSCORE } from "../game/wizard.js";
-import { createTownStores, storeUpdate, storeWillBuy } from "../store/store.js";
+import { createTownStores, registerCoreStoreBehaviour, StoreBehaviourRegistry, storeUpdate, storeWillBuy, } from "../store/store.js";
 import { homeCarry, homeRetrieve, homeStash, storeBuy, storeSell, storeSellFloor, } from "../store/transact.js";
 import { storeCheckNum } from "../store/store.js";
 import { priceItem } from "../store/price.js";
-import { formatMonsterMessage, formatMonsterMessageByName, formatMonsterMessageShowDamage, formatPainMessage, formatPainMessageShowDamage, monMessageSoundType, painMessageCode, } from "../game/mon-message.js";
-import { AutoinscriptionRegistry, RuneNoteRegistry, buildRuneList, runeKey, FlavorKnowledge, EverseenKnowledge, equipLearnElement, makeRuneEnv, NOOP_FLAVOR_AWARE_DEPS, OBJ_NOTICE, objectLearnOnWield, playerLearnInnate, playerLearnAllRunes, } from "../obj/knowledge.js";
+import { addMonsterMessage, addMonsterMessageShowDamage, messagePain, messagePainShowDamage, monMessageCodeByName, } from "../game/mon-message.js";
+import { AutoinscriptionRegistry, RuneNoteRegistry, buildRuneList, runeKey, FlavorKnowledge, EverseenKnowledge, equipLearnElement, equipLearnFlag, makeRuneEnv, NOOP_FLAVOR_AWARE_DEPS, OBJ_NOTICE, objectLearnOnWield, playerLearnInnate, playerLearnAllRunes, } from "../obj/knowledge.js";
 import { flavorInit } from "../obj/flavor.js";
 import { ELEM_MAX } from "../obj/types.js";
 import { ArtifactState, ObjAllocState } from "../obj/make.js";
 import { monsterDeath, installNonplayerHitDeps } from "../game/mon-death.js";
-import { newGear, outfitPlayer, gearGet, calcInventory, minusAc as applyMinusAc, objectCopyAmt, } from "../game/gear.js";
+import { newGear, outfitPlayer, gearGet, gearTotalWeight, calcInventory, combinePackForPlayer, minusAc as applyMinusAc, objectCopyAmt, } from "../game/gear.js";
 import { objectValue as computeObjectValue } from "../obj/value.js";
 import { buildCurseTimedFoil } from "../obj/object.js";
 import { createDefaultRegistry, installMeleeSideEffects, search } from "../game/player-turn.js";
+import { noticeNewLevel } from "../game/notice.js";
+import { cmdDisableRepeatFloorItem } from "../game/repeat.js";
 import { buildTempBrandSlay, playerIncCheck } from "../player/timed.js";
+import { describeObject, knownDescOf, objectKnownView } from "../game/describe.js";
+import { knownBonusView, objectFlagIsKnown, objectKnownShadow, } from "../obj/known-object.js";
+import { ODESC, objDescNameFormat } from "../obj/desc.js";
 import { disturb, installRunning } from "../game/player-path.js";
 import { bindCore, bootLevel, genDeps } from "./boot.js";
 import { dungeonGetNextLevel, isQuest, playerQuestsReset, questCheck, } from "../game/quest.js";
 import { Rng } from "../rng.js";
 import { OptionState } from "../player/options.js";
+import { optionsInitDefaults } from "../player/options-file.js";
+import { host } from "../host/io.js";
 import { doRandart, RANDNAME_TOLKIEN } from "../obj/randart.js";
 import { makeActivationSummarizer } from "../obj/effects-info.js";
-import { generateLevel, getJoinInfo } from "../gen/generate.js";
+import { generateLevel, getJoinInfo, getMinLevelSize, } from "../gen/generate.js";
 import { iToGrid } from "../gen/util.js";
 import { deserializeAutoinscriptions, deserializeEverseen, deserializeFlavor, deserializeIgnore, deserializeChunk, deserializeFloor, buildFeatRemap, deserializeArtifactsCreated, deserializeArtifactFlags, deserializeGear, deserializeKnown, deserializeLevelCache, deserializeLore, deserializeMessages, deserializeMonster, deserializePlayer, deserializeStores, deserializeTraps, serializeGame, } from "./save.js";
 import { migrateSave } from "./save-migrate.js";
@@ -139,6 +149,28 @@ export function resolveTargetItem(state, req) {
     state.itemRequest = req;
     return null;
 }
+/**
+ * The getAimTarget seam body: effect_handler_TELEPORT_TO's own get_aim_dir
+ * (effect-handler-general.c:2770-2778), resolved from the direction the shell
+ * pre-asked and rode on the command.
+ *
+ *   do { if (!get_aim_dir(&dir)) return false; } while (dir == DIR_TARGET && !target_okay());
+ *   if (dir == DIR_TARGET) target_get(&aim);
+ *   else aim = loc_offset(start, ddx[dir], ddy[dir]);
+ *
+ * The C loop re-asks until the answer is usable; a port that cannot block
+ * instead treats an unusable answer as the cancel the loop's ESC produces. No
+ * RNG either way.
+ */
+export function resolveEffectAim(state) {
+    const dir = state.effectAimDir;
+    if (dir === null || dir === undefined || dir < 1 || dir > 9)
+        return null;
+    /* DIR_TARGET: the while() means a target that is gone is not a direction. */
+    if (dir === 5)
+        return targetOkay(state) ? targetGet(state) : null;
+    return locSum(state.actor.grid, DDGRID[dir] ?? loc(0, 0));
+}
 /**
  * The chooseCurse seam body (get_curse, effect-handler-general.c): return the
  * shell's preset curse index when it is one of the removable curses, else the
@@ -155,18 +187,22 @@ export function resolveTargetCurse(state, removable) {
 /**
  * The real, in-play FlavorAwareDeps for object_flavor_aware's ignore fix
  * (obj-knowledge.c L2276-2279, #89): reads the live ignore settings so a
- * kind ignored while unaware keeps being ignored once identified, and flags
- * player->upkeep->notice's PN_IGNORE (state.noticeIgnore) so a later
- * ignore_drop() pass (#25 UI, not yet wired) can react. Shared by the two
- * in-play becomes-aware sites: game/obj-cmd.ts's item-use knowledge gain
+ * kind ignored while unaware keeps being ignored once identified, and raises
+ * player->upkeep->notice's PN_IGNORE (obj-knowledge.c L2279) so the next
+ * notice_stuff runs an ignore_drop pass. Shared by the two in-play
+ * becomes-aware sites: game/obj-cmd.ts's item-use knowledge gain
  * (installObjCommands below) and store/transact.ts's buy/sell (makeStoreApi).
+ *
+ * This used to set a bespoke `state.noticeIgnore` boolean because there was no
+ * notice mask to raise a bit in - and nothing ever read the boolean, which is
+ * PORT_TODO 2.5. It raises the real bit now.
  */
 function flavorAwareDeps(state) {
     return {
         isIgnoredUnaware: (kidx) => state.ignore.kindIsIgnoredUnaware(kidx),
         ignoreWhenAware: (kidx) => state.ignore.kindIgnoreWhenAware(kidx),
         requestIgnoreNotice: () => {
-            state.noticeIgnore = true;
+            state.actor.player.upkeep.notice |= PN.IGNORE;
         },
     };
 }
@@ -178,7 +214,7 @@ function flavorAwareDeps(state) {
  * captured by every closure, so a level change may swap the state's chunk
  * and entity stores in place without rewiring.
  */
-function wireGame(state, reg, players, pstate, seedFlavor, pack) {
+function wireGame(state, reg, players, pstate, seedFlavor) {
     // Rolling message log (message.c file-statics; gap 12.8). Shared producer for
     // both new-game and load paths: startGame arrives with no log so this creates
     // it; loadGame already restored one via deserializeMessages, so preserve it
@@ -212,7 +248,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
     // ignore_item_ok (obj-ignore.c): the player's ignore settings resolved with
     // live flavor awareness. Everything reads it through state.isIgnored so the
     // floor / pickup / running / projection paths need no flavor coupling.
-    state.isIgnored = (obj) => ignoreItemOk(obj, state.ignore, flavor.isAware(obj.kind));
+    state.isIgnored = (obj) => ignoreItemOk(obj, objectKnownView(state, obj), state.ignore, flavor.isAware(obj.kind));
     // object_flavor_is_aware (obj-knowledge.c): the presentation view models
     // (obj-list.c, #25) read kind awareness through this seam, keeping them
     // decoupled from the flavor store just like isIgnored.
@@ -247,12 +283,16 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
     });
     // Rune learning (obj-knowledge.c learn-by-use): the registry tables plus
     // live equipment access. Reads through the state object so level changes
-    // and gear swaps need no rewiring.
+    // and gear swaps need no rewiring. `describeBase` is the real ODESC_BASE for
+    // the six rune / flag / curse messages (PORT_TODO 3.23); it is supplied HERE
+    // and only here, because the two other makeRuneEnv calls in this file are the
+    // documented placeholders wireGame replaces.
     state.runeEnv = makeRuneEnv((slot) => state.gear.store.get(state.actor.player.equipment[slot] ?? 0) ?? null, (v) => state.rng.randcalcVaries(v), {
         brands: reg.objects.brands,
         slays: reg.objects.slays,
         curses: reg.objects.curses,
         properties: reg.objects.properties,
+        describeBase: (obj) => describeObject(state, obj, ODESC.BASE),
         ...(reg.projections
             ? {
                 elementNames: reg.projections
@@ -278,6 +318,31 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
     // fail-chance display always read the current stats.
     const liveStatInd = [...pstate.statInd];
     state.statInd = liveStatInd;
+    /**
+     * calc_bonuses(p, &known_state, TRUE, TRUE) (player-calcs.c:2349): the SECOND
+     * derive, the one the player is SHOWN. Same options and the same `update`
+     * flag upstream passes - its side effects (zeroing TMD_FASTCAST on a stun
+     * grade) are idempotent, so running them twice is what upstream does and
+     * costs nothing.
+     *
+     * knownBonusView is the whole difference: it hands the equipment loop each
+     * worn item's known twin, so an unlearned rune's to_a / to_h / to_d / resist
+     * / flag is left out of what gets printed while staying in what gets rolled.
+     *
+     * A named function rather than three lines inside refreshDerived because it
+     * is also called ONCE at the end of wiring. Without that seed, actor
+     * .knownCombat would hold the real state until the first equipment change,
+     * and a loaded character wearing unidentified gear would see true numbers on
+     * the sidebar for exactly as long as they stood still.
+     */
+    const refreshKnownCombat = (p, bonusOptions) => {
+        const known = calcBonuses(p, {
+            ...bonusOptions,
+            knownOnly: (obj) => knownBonusView(obj, p, state.runeEnv, knownDescOf(state)),
+        });
+        state.knownPlayerState = known;
+        state.actor.knownCombat = toCombatState(known);
+    };
     const refreshDerived = () => {
         const p = state.actor.player;
         const equipment = p.equipment.map((h) => h ? gearGet(state.gear, h) : null);
@@ -285,15 +350,17 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
         /* p->state before the memcpy at the end of calc_bonuses: the encumbrance
          * notices below diff against it (player-calcs.c:2412-2453). */
         const before = derived;
-        derived = calcBonuses(p, {
+        const bonusOptions = {
             equipment,
             timedEffects: players.timed,
             curses: reg.objects.curses,
             update: true,
             depth: state.chunk.depth,
             isDaytime: daytime,
-        });
+        };
+        derived = calcBonuses(p, bonusOptions);
         state.playerState = derived;
+        refreshKnownCombat(p, bonusOptions);
         /* calc_light's town-daytime branch (player-calcs.c 1608-1611) flags
          * PU_UPDATE_VIEW | PU_MONSTERS before returning; reinstate that refresh so
          * ambient town light tracks the day/night cycle. */
@@ -353,30 +420,47 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
      * with nothing installed.
      *
      * `??=` rather than `=`: a host that wants its own events bus or light sources
-     * still replaces this, and the web does. Wired in wireGame so startGame and
-     * loadGame both get it - a resumed character has the same right to a map as a
-     * new one.
+     * can still replace this. NOTE that no shipped host does - the web calls core's
+     * (main.ts:8484 throws if wireGame did not install one) and so does the MCP
+     * session. This comment used to assert "and the web does", which is how the
+     * hardcoded `[]` below survived: a seam documented as host-supplied reads as
+     * deliberate rather than empty. Wired in wireGame so startGame and loadGame
+     * both get it - a resumed character has the same right to a map as a new one.
      *
      * The viewer fields come from `viewerStateOf` (game/known.ts) rather than being
      * spelled out again here, because spelling them out twice is how both hosts came
      * to pass `chunk.depth` where cave-view.c:778 reads `p->lev`.
      */
     state.updateFov ??= (s) => {
-        updateView(s.chunk, viewerStateOf(s), { maxSight: reg.constants.maxSight, feelingNeed: reg.constants.feelingNeed }, [], s.events);
+        updateView(s.chunk, viewerStateOf(s), { maxSight: reg.constants.maxSight, feelingNeed: reg.constants.feelingNeed }, 
+        /* calc_lighting's monster scan (cave-view.c L696-719). Was `[]`. */
+        monsterLightSources(s), s.events, 
+        /* cave-view.c:852: the object feeling, the moment the player has seen
+         * enough of the level to earn it. objOnly is display_feeling(true) - the
+         * one-line object half, not the joined ^F line - and the disturb is
+         * upstream's, so a run or a rest stops on the news. */
+        () => {
+            displayFeeling(s, { objOnly: true });
+            disturb(s);
+        });
         noteSpots(s);
     };
+    /* The live calc_inventory inputs, shared by every closure below that has to
+     * re-derive upkeep->inven[] / upkeep->quiver[]. One function rather than a
+     * copy per seam, so a change to the options bag reaches all of them. */
+    const liveCalcInv = () => ({
+        ammoTval: state.playerState?.ammoTval ?? 0,
+        objectValue: (obj) => computeObjectValue(reg.objects, obj, 1, true),
+        rogueLike: state.options?.get("rogue_like_commands") ?? false,
+        characterDungeon: true,
+        ...(state.msg ? { msg: state.msg } : {}),
+    });
     /* game-world.c:941-947: the C refreshes upkeep->inven[] before its
      * catch-all pack_overflow(NULL).  This closure has the same live
      * calc_inventory inputs used by pickup and command paths, preserving the
      * earlier_object order of the derived gear.inven view. */
     state.overflowPack = () => {
-        const calcInv = {
-            ammoTval: state.playerState?.ammoTval ?? 0,
-            objectValue: (obj) => computeObjectValue(reg.objects, obj, 1, true),
-            rogueLike: state.options?.get("rogue_like_commands") ?? false,
-            characterDungeon: true,
-            ...(state.msg ? { msg: state.msg } : {}),
-        };
+        const calcInv = liveCalcInv();
         /* notice_stuff()/handle_stuff() precede pack_overflow(NULL) at
          * game-world.c:941-947; materialize the current upkeep->inven[] analogue
          * before selecting its final entry. */
@@ -386,6 +470,11 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
             ...(state.msg ? { msg: state.msg } : {}),
         });
     };
+    /* notice_stuff's PN_COMBINE branch (player-calcs.c L2546-2549). combine_pack
+     * ends in its own calc_inventory, so this needs the same options bag. */
+    state.combinePack = () => {
+        combinePackForPlayer(state.gear, state.actor.player, reg.constants, liveCalcInv());
+    };
     /* Stash the class list so refreshTownStores can expand the bookseller's
      * town-book always lines (object_kind_to_book, store.c:208-231). */
     state.classes = players.classes;
@@ -467,8 +556,11 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
         const expRace = mon.race;
         /* Shapechanged monsters revert on death (mon-util.c L1027). */
         monsterRevertShape(state, mon);
-        /* player_kill_monster: dead uniques stay dead (max_num = 0). The flag
-         * is session-lifetime; persisting it rides the save format (ledgered). */
+        /* player_kill_monster: dead uniques stay dead (max_num = 0). This is NOT
+         * session-lifetime, contrary to what this comment used to say: the save
+         * carries the lore, and the load path re-derives maxNum = 0 for every
+         * unique with pkills > 0 (see the SV-01 block below), exactly as
+         * load.c:532-535 does. Nothing about it rides an unbuilt save format. */
         if (mon.race.flags.has(RF.UNIQUE)) {
             /* bug-fixes #4245 ("Unique coming back to life?"): a unique can produce
              * multiple "Killed X" kill-history entries via shape-change / projection
@@ -615,6 +707,26 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
         const floorEnv = {
             isIgnored: (obj) => state.isIgnored(obj),
             ...(preds ? { isTrap: preds.isTrap } : {}),
+            /* floor_carry_fail's message (obj-pile.c:992-1011). Neither of these two
+             * had a producer, so an item that broke on a throw, or vanished because
+             * the floor had no room for it, disappeared in total silence - the player
+             * was simply short an item with no line to explain it. object_desc's mode
+             * is ODESC_BASE (:1002), the bare name. */
+            onBreak: (obj, broke) => {
+                const name = describeObject(state, obj, ODESC.BASE);
+                const verb = broke
+                    ? obj.number > 1
+                        ? "break"
+                        : "breaks"
+                    : obj.number > 1
+                        ? "disappear"
+                        : "disappears";
+                state.msg?.(`The ${name} ${verb}.`);
+            },
+            /* sound(MSG_DROP) (obj-pile.c:1150), the moment an object lands. */
+            onDrop: () => {
+                state.sound?.(MSG.DROP);
+            },
         };
         // Monster-death loot deps: makeDeps builds the objects, reg.objects looks
         // up specified drops, floorEnv places them, state.lore feeds the theft
@@ -625,32 +737,92 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
             floorEnv,
             lore: state.lore,
         };
-        const teleport = preds
-            ? {
-                isPlayerTrap: preds.isPlayerTrap,
-                isWarded: preds.isWarded,
-                isWebbed: preds.isWebbed,
-                /* is_quest (player-quest.c L140): the real implementation behind the
-                 * force_descend / teleport-level guards (effect-general.ts,
-                 * effect-teleport.ts, effect-terrain.ts) - a quest level cannot be
-                 * skipped or recalled away from. */
-                isQuest: (depth) => isQuest(state.actor.player, depth),
-                /* dungeon_get_next_level (player-util.c:1147). This seam existed but
-                 * nothing ever wired it, so every consumer silently degraded to a
-                 * bare `depth + dir` - no stair_skip, no max_depth clamp and, worst,
-                 * no quest scan. */
-                getNextLevel: (from, dir) => dungeonGetNextLevel(state.actor.player, from, dir, state.z),
-                changeLevel: (targetDepth) => {
-                    state.targetDepth = targetDepth;
-                    state.generateLevel = true;
-                },
-                /* player_handle_post_move eval_trap half (player-util.c:1627-1629):
-                 * immediate traps at the landing grid after teleport / thrust. */
-                onPlayerPostMove: (_byMonster) => {
-                    state.onPlayerMoved?.(state, state.actor.grid);
-                },
-            }
-            : undefined;
+        /* The teleport-family environment (game/effect-teleport.ts TeleportEnv).
+         *
+         * This used to be `preds ? {...seven fields} : undefined` - so a game
+         * without the trap registry had NO teleport env at all, and nine of the
+         * sixteen fields had no producer anywhere even when it did. Each of those
+         * nine is a live upstream read whose subsystem has since been built, so the
+         * "inert default" they fell back on was a silently missing feature: the
+         * OF_NO_TELEPORT curse never blocked a teleport and its rune was never
+         * learned, a teleport could land the player in lava, nexus resistance did
+         * not foil a hostile teleport-level, and Dimension Door aborted every time.
+         * Only the trap predicates are conditional now.
+         *
+         * The three player reads are GETTERS, not values: this object is built once
+         * per game and every consumer holds the same reference, so a captured
+         * boolean would freeze the answer at wiring time - before the player ever
+         * picked up the cursed ring. */
+        const teleport = {
+            ...(preds
+                ? {
+                    isPlayerTrap: preds.isPlayerTrap,
+                    isWarded: preds.isWarded,
+                    isWebbed: preds.isWebbed,
+                }
+                : {}),
+            /* square_isdamaging (cave-square.c): fiery terrain. Nothing supplied it,
+             * so has_teleport_destination_prereqs happily landed the player in lava. */
+            isDamaging: (grid) => state.chunk.isDamaging(grid),
+            /* is_quest (player-quest.c L140): the real implementation behind the
+             * force_descend / teleport-level guards (effect-general.ts,
+             * effect-teleport.ts, effect-terrain.ts) - a quest level cannot be
+             * skipped or recalled away from. */
+            isQuest: (depth) => isQuest(state.actor.player, depth),
+            /* dungeon_get_next_level (player-util.c:1147). This seam existed but
+             * nothing ever wired it, so every consumer silently degraded to a
+             * bare `depth + dir` - no stair_skip, no max_depth clamp and, worst,
+             * no quest scan. */
+            getNextLevel: (from, dir) => dungeonGetNextLevel(state.actor.player, from, dir, state.z),
+            changeLevel: (targetDepth) => {
+                state.targetDepth = targetDepth;
+                state.generateLevel = true;
+            },
+            /* player_handle_post_move eval_trap half (player-util.c:1627-1629):
+             * immediate traps at the landing grid after teleport / thrust. */
+            onPlayerPostMove: (_byMonster) => {
+                state.onPlayerMoved?.(state, state.actor.grid);
+            },
+            /* handle_stuff(player) after a monster teleports (PU_UPDATE_VIEW): the
+             * monster's own visibility and lighting are monsterSwap's, but the
+             * player's field of view is not, and a light-carrying monster arriving
+             * next door has to change what the player can see. */
+            onMonsterPostMove: (_midx) => {
+                state.updateFov?.(state);
+            },
+            /* player_of_has(OF_NO_TELEPORT) and its equip_learn_flag, the pair that
+             * makes a Teleportation-forbidding curse do anything at all. */
+            get hasNoTeleport() {
+                return playerOfHas(state, OF.NO_TELEPORT);
+            },
+            onLearnNoTeleport: () => {
+                equipLearnFlag(state.actor.player, state.runeEnv, OF.NO_TELEPORT);
+            },
+            /* player_resists(player, ELEM_NEXUS) (player-util.c): res_level > 0, off
+             * the LIVE derived state, so a swapped-in resist ring counts. */
+            get resistsNexus() {
+                return (state.playerState?.elInfo[ELEM.NEXUS]?.resLevel ?? 0) > 0;
+            },
+            /* player->max_depth: EF_TELEPORT_LEVEL's force_descend target is the
+             * deepest level REACHED, not the current one. Defaulting to the current
+             * depth made "deep descent"-style descent one level, every time. */
+            get maxPlayerDepth() {
+                return state.actor.player.maxDepth;
+            },
+            /* z_info->max_depth, from the bound constants rather than the hardcoded
+             * 128 the default assumed - a mod may ship a different dungeon bottom. */
+            maxDepth: reg.constants.maxDepth,
+            /* OPT(player, birth_force_descend) off the live option store. */
+            get forceDescend() {
+                return state.options?.get("birth_force_descend") ?? false;
+            },
+            /* get_aim_dir inside effect_handler_TELEPORT_TO (Dimension Door,
+             * effect-handler-general.c:2770-2778). The port cannot block mid-turn, so
+             * the shell asks first and rides the direction on the command; core does
+             * the resolution because `start` is the player's grid and the offset
+             * arithmetic belongs next to the handler, not in a front end. */
+            getAimTarget: () => resolveEffectAim(state),
+        };
         // Glyph / web creation needs the trap system; trapDeps joins below
         // once it is built (the mutual reference is deliberate). The stat
         // adjectives (desc_stat) come from the bound object properties, and
@@ -712,9 +884,28 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
              * PARSE_ERROR_INVALID_EFFECT, exactly as before. */
             lookupEffect: (name) => (effects.isRegistered(name) ? name : null),
         };
+        /* Published on the state so buildObjectEffectChain has these by default.
+         * The chain is rebuilt from raw records on every USE and every INSPECT, and
+         * a caller that omitted them could not resolve `SUMMON:ANY` - it threw
+         * mid-turn. See GameState.effectInject. */
+        state.effectInject = inject;
+        /* The three projection handler tables (game/projection-handlers.ts), seeded
+         * with core's 69. Built here, per game, for the same reason as the blow and
+         * store registries: a module-level table would carry one character's mod
+         * into the next character's game.
+         *
+         * Handed to the engine BY IDENTITY below - `worldEnv` and the playerHandlers
+         * dep hold these very Maps. A mod's register() runs after this wiring, so a
+         * snapshot would be a seam that ignored every mod. */
+        const projectionHandlers = new ProjectionHandlerRegistry();
+        state.projectionHandlers = projectionHandlers;
         // project_o / project_f world access; trapDeps joins it below once the
         // trap system is wired (the mutual reference is deliberate).
-        const worldEnv = { makeDeps };
+        const worldEnv = {
+            makeDeps,
+            featHandlers: projectionHandlers.feat.table,
+            objHandlers: projectionHandlers.obj.table,
+        };
         /* The projection view reads the LIVE derived state, so worn resistance
          * gear reduces projection damage and equipment swaps take effect. */
         const playerActor = basicPlayerActor(state, {
@@ -751,20 +942,19 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                             monsterDeath(state, m, deathDeps);
                     },
                     /* add_monster_message: "the kobold dies", "wakes up", "catches
-                     * fire" - the MON_MSG grammar, routed to the game's message sink so
-                     * a shell shows ranged/spell/status monster messages the same way
-                     * melee shows "You hit/slay the X". The projection already gates on
+                     * fire" - STACKED on the mon_msg[] queue, not emitted here, so one
+                     * breath over a pit produces "8 kobolds die." and the deaths come
+                     * last. noticeStuff drains it. The projection already gates on
                      * visibility before calling this. */
-                    message: (m, msgCode, _delay, damage) => {
+                    message: (m, msgCode, delay, damage) => {
                         /* add_monster_message_show_damage (mon-msg.c:288) when the driver
                          * passed a damage total, else add_monster_message (L252). */
-                        const text = damage === undefined
-                            ? formatMonsterMessage(m, msgCode)
-                            : formatMonsterMessageShowDamage(m, msgCode, damage);
-                        const type = monMessageSoundType(msgCode, m.race);
-                        if (text)
-                            state.msg?.(text, type);
-                        state.sound?.(type);
+                        if (damage === undefined) {
+                            addMonsterMessage(state, m, msgCode, delay);
+                        }
+                        else {
+                            addMonsterMessageShowDamage(state, m, msgCode, delay, damage);
+                        }
                     },
                     /* OPT(player, show_damage): project_m_player_attack's display_dam
                      * (project-mon.c:1111) picks the *_show_damage message variants. */
@@ -772,19 +962,18 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                     /* message_pain: the graded "shrugs off the attack" / "cries out in
                      * pain" line for a monster hurt but not killed. */
                     messagePain: (m, dam, showDamage) => {
-                        const text = showDamage
-                            ? formatPainMessageShowDamage(m, dam)
-                            : formatPainMessage(m, dam);
-                        const type = monMessageSoundType(painMessageCode(m, dam), m.race);
-                        if (text)
-                            state.msg?.(text, type);
-                        state.sound?.(type);
+                        if (showDamage)
+                            messagePainShowDamage(state, m, dam);
+                        else
+                            messagePain(state, m, dam);
                     },
-                    /* mon_set_timed's queued status messages (slowed, confused, held). */
+                    /* mon_set_timed's queued status messages (slowed, confused, held),
+                     * add_monster_message(mon, m_note, true) at mon-timed.c:215 - the
+                     * delayed pass, so a status line follows the blow that caused it. */
                     timedMessage: (m, note) => {
-                        const text = formatMonsterMessageByName(m, note);
-                        if (text)
-                            state.msg?.(text);
+                        const code = monMessageCodeByName(note);
+                        if (code !== null)
+                            addMonsterMessage(state, m, code, true);
                     },
                     /* Lore learning when a projection's outcome is seen. */
                     learnRaceFlag: (m, flag) => loreLearnFlagIfVisible(getLore(state.lore, m.race), m, flag),
@@ -793,8 +982,31 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                     revertShape: (m) => {
                         monsterRevertShape(state, m);
                     },
+                    /* poly_race + the delete/place swap (project-mon.c:45, :1225-1229).
+                     * Both halves are supplied, and separately, because upstream queues
+                     * MON_MSG_CHANGE between them - naming the old monster while it still
+                     * exists. Until this was wired the hook had NO supplier at all, so a
+                     * Wand of Polymorph rolled its saving throw, spent the charge and then
+                     * reported "maintains its shape" every single time.
+                     *
+                     * ambientPlaceDeps is declared later in this same function; the
+                     * forward reference is safe for the same reason state.monsterMultiply
+                     * (which uses it too) is - these arrows only run during play. Reusing
+                     * it rather than a private table also means the polymorphed monster
+                     * gets its held drops, as place_monster does for any origin != 0. */
+                    polyRace: (race) => polyRace(state, race, state.chunk.depth, ambientPlaceDeps),
+                    replaceMonster: (m, race) => polymorphMonster(state, m, race, ambientPlaceDeps),
                     /* PROJ_AWAY_ALL teleports and PROJ_FORCE knockback for monsters. */
-                    teleport: (m, dist) => teleportMonster(state, m.midx, dist, teleport ?? {}),
+                    teleport: (m, dist) => teleportMonster(state, m.midx, dist, teleport),
+                    /* update_mon(mon, cave, false) on a monster that SURVIVED the
+                     * projection (project-mon.c:1262). Unsupplied, so a monster that was
+                     * polymorphed, knocked back, woken or revealed by a spell kept its
+                     * pre-projection visibility until something else happened to move it.
+                     * updateMon has been ported since the FOV work; this hook was simply
+                     * never given a producer. */
+                    onUpdate: (mon) => {
+                        updateMon(state, mon, false);
+                    },
                     /* project-mon.c:183-185 / 208-212 + player thrust landing. */
                     thrustAway: (centre, target, gridsAway) => thrustAway(state, centre, target, gridsAway, {
                         onPlayerPostMove: () => {
@@ -819,7 +1031,21 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                         projections: reg.projections,
                         expDeps,
                         lifeDrainPercent: reg.constants.lifeDrainPercent,
-                        ...(teleport ? { teleport } : {}),
+                        playerHandlers: projectionHandlers.player.table,
+                        /* project_p's OWN messages (project-player.c): "You resist the
+                         * effect!", "The intense heat saps you.", "Your eyes fill with
+                         * smoke!" - thirty-odd lines across the 21 arms, plus every timed
+                         * effect's onMessage, which makePlayerSideEffects gates on this
+                         * same optional.
+                         *
+                         * UNSUPPLIED UNTIL 2026-08-09, so all of them were dropped in the
+                         * live game and only the outer "You are hit by fire!" survived.
+                         * The seam was optional, every harness that exercised the arms
+                         * supplied it, and the one caller that matters did not - found by
+                         * a mod handler calling ctx.msg and getting silence
+                         * (session/projection-registry-wiring.test.ts). */
+                        msg: (text) => state.msg?.(text),
+                        teleport,
                     }),
                     /* adjust_dam(actual=true) equip_learn_element (project-player.c
                      * L60-62, audit 01 P5): being hit by an element teaches the resist
@@ -853,6 +1079,14 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
          * are gated. Absent, every increase was allowed. Same shape as
          * buildFailRuneEnv / makePlayerSideEffects. */
         const incQueries = makeIncCheckQueries(state);
+        /* player_inc_check's equip-learn side effects on the INTERPRETER path -
+         * traps, potions, wands, player spells. Only mon-cast.ts supplied incHooks
+         * before, so a trap you were immune to taught nothing, where upstream's
+         * non-lore branch always calls equip_learn_flag / equip_learn_element
+         * (player-timed.c:945, :967, :985). No monster is passed: these sources are
+         * not cave->mon_current, so update_smart_learn and "You resist the effect!"
+         * correctly stay silent. */
+        const incHooks = makeIncCheckHooks(state);
         const envDeps = {
             timedTable: players.timed,
             // Effect status/damage messages ("You feel better", "You feel yourself
@@ -860,6 +1094,10 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
             // them; absent, they would drop.
             onMessage: (text, msgt) => state.msg?.(text, msgt),
             incQueries,
+            incHooks,
+            /* player_set_timed's notify suppression: the obj_k reads that silence a
+             * message duplicating known player state (player-timed.c:828-839). */
+            notifyQueries: makeTimedNotifyQueries(state),
             /* on_begin_effect / on_end_effect (audit 01 T2): the interpreter timed
              * path (a SCRAMBLE / SPRINT potion or spell) must run the chain too, not
              * just the world clock. The thunk reads runTimedTransition (assigned just
@@ -892,7 +1130,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                     state,
                     cast,
                     takeHitHooks: sharedTakeHitHooks,
-                    ...(teleport ? { teleport } : {}),
+                    teleport,
                     general,
                     item,
                     summon,
@@ -913,7 +1151,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
             cast,
             envDeps,
             inject,
-            ...(teleport ? { teleport } : {}),
+            teleport,
             general,
             item,
             summon,
@@ -927,7 +1165,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
             change: (m) => monsterChangeShape(state, m, {
                 summon,
                 spells: reg.monsters.spells,
-                ...(teleport ? { teleport } : {}),
+                teleport,
             }),
             revert: (m) => monsterRevertShape(state, m),
         };
@@ -943,7 +1181,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
             envDeps,
             saveSkill: pstate.skills[SKILL.SAVE] ?? 0,
             inject,
-            ...(teleport ? { teleport } : {}),
+            teleport,
             general,
             summon,
             monShape,
@@ -971,10 +1209,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
          * path - die/pain messages, loot via monster_death, fear rolls. The
          * scheduler reads these for monster_take_terrain_damage; without them
          * terrain damage was inert. */
-        installNonplayerHitDeps(state, {
-            ...deathDeps,
-            message: (text) => state.msg?.(text),
-        });
+        installNonplayerHitDeps(state, deathDeps);
         /* does_resist lore (mon-timed.c L107-110, gap 8.6): when a monster resists a
          * timed effect via a race flag, learn that flag into visible lore. The
          * timed layer has no deps param (get_lore is a global upstream), so register
@@ -985,6 +1220,17 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
          * applies its full elemental / status / stat / theft / terrain
          * consequences in upstream RNG order. EF_EARTHQUAKE (SHATTER) routes
          * through the effect interpreter so its internal draws are shared. */
+        /* The blow-effect handler table (combat/mon-melee.ts). Built here, per game,
+         * and seeded with core's 30: a module-level singleton would carry one
+         * character's mod-registered blow into the next character's game. */
+        const blowEffects = new BlowEffectRegistry();
+        registerCoreBlowEffects(blowEffects);
+        state.blowEffects = blowEffects;
+        /* Store behaviour (store/store.ts): what a shop will buy, and how many of a
+         * thing it stocks. Per game for the same reason as the blow table. */
+        const storeBehaviour = new StoreBehaviourRegistry();
+        registerCoreStoreBehaviour(storeBehaviour);
+        state.storeBehaviour = storeBehaviour;
         state.monBlowEnv = makeMonBlowEnv(state, {
             timed: players.timed,
             actor: playerActor,
@@ -994,7 +1240,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
             adjDexSafe: adj_dex_safe,
             packSize: reg.constants.packSize,
             makeDeps,
-            ...(teleport ? { teleport } : {}),
+            teleport,
             earthquake: (mon, radius) => {
                 effects.effectSimple(EF.EARTHQUAKE, buildEffectContext(state, envDeps), {
                     origin: sourceMonster(mon.midx),
@@ -1016,7 +1262,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
              * is applied by applyAutoinscription. */
             autoNote: (kind, aware) => state.autoinscribe?.get(kind.kidx, aware) ?? null,
             inject,
-            ...(teleport ? { teleport } : {}),
+            teleport,
             general,
             item,
             summon,
@@ -1064,7 +1310,10 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                     radius: 10,
                 });
             },
-            temp: buildTempBrandSlay(state.actor.player, pack.player.timed, reg.objects.brands, reg.objects.slays),
+            /* The ONE bound instance (state.tempBrandSlay), not a private second copy.
+             * This used to build its own, which is why nothing outside the melee path
+             * could ask the question - PORT_TODO 3.20. */
+            temp: state.tempBrandSlay,
         });
         // Player spellcasting (cast / study) for casting classes.
         installSpellCommands(registry, {
@@ -1073,7 +1322,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                 cast,
                 envDeps,
                 inject,
-                ...(teleport ? { teleport } : {}),
+                teleport,
                 general,
                 item,
                 summon,
@@ -1098,7 +1347,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
         // Player ranged attacks (fire launcher + ammo, throw an object). The hit
         // math is combat/ranged.ts; the front-end walks the missile's path and
         // routes hit / death messages through state.msg like the other commands.
-        installRangedCommands(registry);
+        installRangedCommands(registry, floorEnv);
         // Traps: disarm + the step-onto-trap hook; a trapdoor drops a level.
         if (reg.traps) {
             trapDeps = {
@@ -1108,7 +1357,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                     cast,
                     envDeps,
                     inject,
-                    ...(teleport ? { teleport } : {}),
+                    teleport,
                     general,
                     item,
                     summon,
@@ -1118,6 +1367,15 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                     msg: (text) => state.msg?.(text),
                     /* player_of_has for trap saves / OF_TRAP_IMMUNE (trap.c:515-539). */
                     playerHasFlag: (flag) => state.playerState?.flags.has(flag) ?? false,
+                    /* is_quest(player->depth) (trap.c:310-311): no trap doors on a quest
+                     * level - the guardian's floor must not open under the player. The
+                     * generation path already supplied this (gen/util.ts, from dun.quest);
+                     * the RUNTIME path did not, so every trap laid after generation - by
+                     * EF_TOUCH:MAKE_TRAP, by square_add_trap - drew from a table that
+                     * still contained the trapdoor on depths 99 and 100. Dropping a kind
+                     * also shifts pick_trap's cumulative total, so the omission moved the
+                     * whole draw, not just the trapdoor. */
+                    isQuest: (depth) => isQuest(state.actor.player, depth),
                     changeLevel: (s) => {
                         /* trap.c:579-582: a TRF_DOWN trapdoor drops you through
                          * dungeon_get_next_level, not blindly one level. */
@@ -1144,7 +1402,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                     cast,
                     envDeps,
                     inject,
-                    ...(teleport ? { teleport } : {}),
+                    teleport,
                     general,
                     item,
                     summon,
@@ -1164,7 +1422,7 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                 cast,
                 envDeps,
                 inject,
-                ...(teleport ? { teleport } : {}),
+                teleport,
                 general,
                 item,
                 summon,
@@ -1280,6 +1538,10 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                 if (canDisturb)
                     disturb(state);
             },
+            /* player_set_timed's notify suppression on the WORLD CLOCK path too -
+             * this is where a timed resist most often ticks down (player-timed.c:
+             * 828-839). */
+            notifyQueries: makeTimedNotifyQueries(state),
             incCheck: (idx) => {
                 const eff = players.timed[idx];
                 return eff ? playerIncCheck(eff, worldIncQueries) : true;
@@ -1294,8 +1556,13 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
              * the {name}/{kind}/{s}/{is} tags in weapon-related timed messages (the
              * temporary-brand on-begin/on-end lines) resolve against the CURRENTLY
              * wielded weapon, so a getter keeps it live across wield/takeoff. name /
-             * kind use the ODESC_BASE approximation (kind name) already adopted across
-             * the port (obj-knowledge.ts). No weapon => the obj == NULL tag forms. */
+             * PORT_TODO 3.23: {name} and {kind} are DIFFERENT upstream functions, and
+             * neither is the raw kind name this used to pass. {name} is
+             * object_desc(ODESC_PREFIX | ODESC_BASE) - so it carries the article - and
+             * {kind} is object_kind_name(kind, easy_know=true), which with easy_know
+             * set is exactly obj_desc_name_format(kind->name, NULL, false). Passing
+             * `w.kind.name` printed the raw `&` and `~` markers to the player.
+             * No weapon => the obj == NULL tag forms. */
             get weapon() {
                 const w = state.actor.weapon;
                 /* No weapon => the obj == NULL tag forms. A sentinel with name/kind
@@ -1305,7 +1572,11 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
                  * that returns undefined. */
                 if (!w)
                     return { name: "hands", kind: "hands", number: 2 };
-                return { name: w.kind.name, kind: w.kind.name, number: w.number };
+                return {
+                    name: describeObject(state, w, ODESC.PREFIX | ODESC.BASE),
+                    kind: objDescNameFormat(w.kind.name, null, false),
+                    number: w.number,
+                };
             },
         },
         /* The same shared consequences drive the world clock's DoT ticks, terrain
@@ -1333,6 +1604,15 @@ function wireGame(state, reg, players, pstate, seedFlavor, pack) {
         ...(wizardEffect ? { effect: wizardEffect } : {}),
         ...(trapDeps ? { trapDeps } : {}),
     };
+    /* Seed p->known_state now that runeEnv and the flavour store are live. */
+    refreshKnownCombat(state.actor.player, {
+        equipment: state.actor.player.equipment.map((h) => h ? gearGet(state.gear, h) : null),
+        timedEffects: players.timed,
+        curses: reg.objects.curses,
+        update: true,
+        depth: state.chunk.depth,
+        isDaytime: isDaytime(state.turn, state.z.dayLength),
+    });
     return { registry, trapDeps, flavor, everseen, effects: effectRegistry, wizardBundles };
 }
 /**
@@ -1345,9 +1625,14 @@ function populateFromLevel(state, level, trapDeps) {
     const spot = level.playerSpot ?? loc(1, 1);
     state.actor.grid = spot;
     placePlayer(state, spot);
-    /* Track the deepest level reached (player->max_depth). */
+    /* Track the deepest level reached: on_new_level (game-world.c:1023-1024)
+     * sets `max_depth = recall_depth = depth`, BOTH of them. recall_depth is the
+     * anchor Word of Recall drops you back to, and this assignment is its only
+     * producer on the ordinary walk down - EF_RECALL re-anchors it only when the
+     * scroll is read in the dungeon. Setting max_depth alone left recall_depth at
+     * 0 forever for a character who never read one below the town. */
     if (level.depth > state.actor.player.maxDepth) {
-        state.actor.player.maxDepth = level.depth;
+        state.actor.player.maxDepth = state.actor.player.recallDepth = level.depth;
     }
     /* A new level clears the decoy (glyph traps do not persist the swap). */
     state.decoy = null;
@@ -1487,10 +1772,16 @@ function sanitizePlayerLoc(state) {
  * object, whose chunk and entity stores are replaced).
  */
 function makeChangeLevel(state, reg, trapDeps, opts = {}) {
-    /* The level stashed when entering an arena: leaving a level FOR an
-     * arena persists it even without birth_levels_persist (generate.c
-     * L1349), and the arena exit restores it. */
-    let arenaStash = null;
+    /* The level stashed when entering an arena lives on GameState
+     * (state.arenaStash), not in this closure: leaving a level FOR an arena
+     * persists it even without birth_levels_persist (generate.c L1349), and
+     * upstream keeps that copy in the chunk_list, which the savefile carries. A
+     * save taken mid-fight used to lose the level behind it and exit onto a
+     * fresh one; now it exits where it went in.
+     *
+     * `inArena` stays a separate flag rather than "the stash exists", because a
+     * save written before the stash was persisted restores with arena_level set
+     * and no stash, and still has to be let out of the arena. */
     let inArena = opts.inArena ?? false;
     return (depth) => {
         /* Consume the pending arrival-stair request (create_up_stair /
@@ -1504,7 +1795,7 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
         if (state.arenaLevel && !inArena) {
             const mon = state.healthWho;
             if (mon) {
-                arenaStash = {
+                state.arenaStash = {
                     chunk: state.chunk,
                     monsters: state.monsters,
                     groups: state.groups,
@@ -1513,6 +1804,11 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
                     known: state.known,
                     decoy: state.decoy ?? null,
                     monMidx: mon.midx,
+                    /* StoredLevel's other two fields. The freeze turn is stamped as
+                     * cave_store does; `join` is empty because an arena exit restores
+                     * the level wholesale and never re-aligns stairs against it. */
+                    turn: state.turn,
+                    join: [],
                 };
                 /* arena_gen (gen-cave.c L3984): 6x6 floor bounded by perm rock,
                  * the player in one corner and the opponent in the other. */
@@ -1559,6 +1855,17 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
                 placePlayer(state, loc(1, 4));
                 inArena = true;
                 delete state.targetDepth;
+                /* on_new_level (game-world.c:1034-1035): PN_COMBINE then notice_stuff,
+                 * one line BEFORE update_stuff, so the combine lands first. */
+                noticeNewLevel(state);
+                /* cmd_disable_repeat_floor_item (game-world.c:1068). Upstream's call is
+                 * in on_leave_level, which this port has no single equivalent of -
+                 * `generateLevel = true` is set at fourteen sites. It rides the ENTRY
+                 * path instead, which is observationally identical: the change is
+                 * synchronous, so the repeat key cannot be pressed between leaving and
+                 * arriving. The old level's pile is gone either way, so a remembered
+                 * args.floor index must not be re-dispatched. */
+                cmdDisableRepeatFloorItem(state.actor.player);
                 state.updateBonuses?.(); /* on_new_level PU_BONUS -> calc_light */
                 state.updateFov?.(state);
                 return;
@@ -1570,8 +1877,8 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
         if (inArena) {
             inArena = false;
             state.arenaLevel = false;
-            const stash = arenaStash;
-            arenaStash = null;
+            const stash = state.arenaStash;
+            delete state.arenaStash;
             if (stash) {
                 /* Restore the level left behind (the player marker stayed). */
                 state.chunk = stash.chunk;
@@ -1598,6 +1905,17 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
                 state.healthWho = null;
                 targetSetMonster(state, null);
                 delete state.targetDepth;
+                /* on_new_level (game-world.c:1034-1035): PN_COMBINE then notice_stuff,
+                 * one line BEFORE update_stuff, so the combine lands first. */
+                noticeNewLevel(state);
+                /* cmd_disable_repeat_floor_item (game-world.c:1068). Upstream's call is
+                 * in on_leave_level, which this port has no single equivalent of -
+                 * `generateLevel = true` is set at fourteen sites. It rides the ENTRY
+                 * path instead, which is observationally identical: the change is
+                 * synchronous, so the repeat key cannot be pressed between leaving and
+                 * arriving. The old level's pile is gone either way, so a remembered
+                 * args.floor index must not be re-dispatched. */
+                cmdDisableRepeatFloorItem(state.actor.player);
                 state.updateBonuses?.(); /* on_new_level PU_BONUS -> calc_light */
                 state.updateFov?.(state);
                 return;
@@ -1606,9 +1924,12 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
              * fresh level of the same depth (ledgered). */
             delete state.oldGrid;
         }
-        /* dungeon_change_level: track the deepest level reached. */
+        /* dungeon_change_level: track the deepest level reached. The same
+         * `max_depth = recall_depth = depth` pair as populateFromLevel, because the
+         * port checks on both the request and the arrival where upstream checks
+         * once in on_new_level - whichever fires first, the other is a no-op. */
         if (depth > state.actor.player.maxDepth) {
-            state.actor.player.maxDepth = depth;
+            state.actor.player.maxDepth = state.actor.player.recallDepth = depth;
         }
         /* birth_levels_persist (#30, off by default): when on, the level being
          * left is frozen into a depth-keyed cache and a previously-frozen target
@@ -1703,10 +2024,25 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
                 installChunkFeatHook(state);
                 refreshTownStores(state, reg);
                 delete state.targetDepth;
+                /* on_new_level (game-world.c:1034-1035): PN_COMBINE then notice_stuff,
+                 * one line BEFORE update_stuff, so the combine lands first. */
+                noticeNewLevel(state);
+                /* cmd_disable_repeat_floor_item (game-world.c:1068). Upstream's call is
+                 * in on_leave_level, which this port has no single equivalent of -
+                 * `generateLevel = true` is set at fourteen sites. It rides the ENTRY
+                 * path instead, which is observationally identical: the change is
+                 * synchronous, so the repeat key cannot be pressed between leaving and
+                 * arriving. The old level's pile is gone either way, so a remembered
+                 * args.floor index must not be re-dispatched. */
+                cmdDisableRepeatFloorItem(state.actor.player);
                 state.updateBonuses?.(); /* on_new_level PU_BONUS -> calc_light */
                 /* only_partial during level-entry FOV (ui-display.c:2522 / cave-view.c:851). */
                 state.chunk.onlyPartial = true;
                 state.updateFov?.(state);
+                /* on_new_level's own disturb (game-world.c:1016-1017), immediately before
+                 * the feeling and the search: arriving on a level cancels whatever was
+                 * still queued from the level you left. */
+                disturb(state);
                 announceFeeling(state, reg);
                 search(state); /* on_new_level (game-world.c:1052). */
                 state.chunk.onlyPartial = false;
@@ -1727,6 +2063,7 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
          * and generateLevel builds exactly as before. */
         const persistCache = state.levelCache;
         let joinInfo;
+        let minSize;
         if (persist && persistCache) {
             const above = persistCache.get(depth - 1)?.join;
             const twoAbove = persistCache.get(depth - 2)?.join;
@@ -1738,13 +2075,27 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
                 ...(below ? { below } : {}),
                 ...(twoBelow ? { twoBelow } : {}),
             });
+            /* get_min_level_size (prepare_next_level L1531-1546): the new level must
+             * be big enough to hold the stairs its frozen neighbours already expect,
+             * or build_staircase_rooms has nowhere to put them and quits. Only the
+             * IMMEDIATE neighbours are measured - a one-off connector two levels away
+             * seeds dun.one_off_* (an avoid list), never a staircase room, so it
+             * imposes no minimum. Starts at 0/0 exactly as the C's locals do. */
+            minSize = getMinLevelSize(below ?? [], false, getMinLevelSize(above ?? [], true));
         }
         /* choose_profile's NOSCORE_JUMPING request (generate.c L824-836): consumed
          * once, cleared as it is passed on, exactly as the C clears the bit. */
         const jumpProfileName = state.jumpProfileName;
         state.jumpProfileName = undefined;
         const g = generateLevel(state.rng, depth, {
-            ...genDeps(reg, true, state.artifacts, state.options?.get("birth_no_artifacts") ?? false, 
+            ...genDeps(reg, true, 
+            /* The player-dependent make_object / make_gold foils. These were
+             * supplied to both STORE paths and to nothing else, so during level
+             * generation - the path they exist for - every book was browsable, no
+             * curse was ever foiled, and generated gold skipped the no-selling
+             * inflation. Two of the three are RNG draws, so the generation stream
+             * itself was off upstream's. */
+            genFoilFields(state), state.artifacts, state.options?.get("birth_no_artifacts") ?? false, 
             /* mon_create_drop's unique theft reduction reads the live lore store. */
             state.lore),
             /* The mod behaviour seam, read at build time (this call is synchronous,
@@ -1774,6 +2125,10 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
              * unconditionally; only read under persist. */
             hasAdjacentAbove: persistCache?.has(depth - 1) ?? false,
             hasAdjacentBelow: persistCache?.has(depth + 1) ?? false,
+            /* get_min_level_size's answer (prepare_next_level L1531-1546), the
+             * only producer these two builder inputs have. Omitted entirely when
+             * not persisting, so generateLevel keeps its own defaults. */
+            ...(minSize ? { minHeight: minSize.height, minWidth: minSize.width } : {}),
             /* birth_connect_stairs (gen-util.c:427-433): lay the arrival stair the
              * stair command requested ("up" after a descent, "down" after an
              * ascent), unless the option is off. Recall/first-spawn leave
@@ -1846,6 +2201,12 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
             g.lightLevel = false;
         }
         delete state.targetDepth;
+        /* on_new_level (game-world.c:1034-1035): PN_COMBINE then notice_stuff, one
+         * line BEFORE update_stuff, so the combine lands first. */
+        noticeNewLevel(state);
+        /* cmd_disable_repeat_floor_item (game-world.c:1068); see the note at the
+         * other level-entry sites for why it rides entry rather than leave. */
+        cmdDisableRepeatFloorItem(state.actor.player);
         /* on_new_level (game-world.c:1034-1037): PU_BONUS -> update_bonuses ->
          * calc_light recomputes cur_light for the NEW depth, then the view is
          * flooded. Without this the daytime-town cur_light (0) leaks into the
@@ -1855,6 +2216,10 @@ function makeChangeLevel(state, reg, trapDeps, opts = {}) {
         /* only_partial during level-entry FOV (ui-display.c:2522 / cave-view.c:851). */
         state.chunk.onlyPartial = true;
         state.updateFov?.(state);
+        /* on_new_level's own disturb (game-world.c:1016-1017), immediately before
+         * the feeling and the search: arriving on a level cancels whatever was
+         * still queued from the level you left. */
+        disturb(state);
         announceFeeling(state, reg);
         search(state); /* on_new_level (game-world.c:1052). */
         state.chunk.onlyPartial = false;
@@ -1959,6 +2324,11 @@ function refreshTownStores(state, reg) {
             deps: storeDeps,
             maxDepth: state.actor.player.maxDepth,
             stores: state.stores,
+            /* history_lose_artifact (store.c:1091 / :1307): an artifact the player
+             * sold into stock and the store then turned over or purged is gone. */
+            onArtifactLost: (art) => state.onArtifactLost?.(art),
+            /* Store behaviour a mod may have added to (StoreBehaviourRegistry). */
+            ...(state.storeBehaviour ? { behaviour: state.storeBehaviour } : {}),
             /* OPT(cheat_xtra) (store.c:1424, :1444). */
             ...(state.options?.get("cheat_xtra")
                 ? { cheatMsg: (text) => state.msg?.(text) }
@@ -2006,17 +2376,24 @@ export function startGame(pack, opts = {}) {
     const reg = bindCore(pack);
     const players = bindPlayer(pack.player);
     registerBookKinds(reg.objects, players.classes);
-    // The player option store (option.c options_init_defaults): seeded from
-    // OPTION_ENTRIES defaults, with the birth/interface choices applied. Built
-    // before level generation so birth_randarts can swap the artifact set first.
-    // Every Angband option (show_damage, center_player, auto_more, ...) ships in
-    // core with its faithful upstream default (OPTION_ENTRIES.normal); the player
-    // changes them in the options menu exactly as upstream. Only explicit birth /
-    // interface CHOICES (birth screen, point-buy) are applied here as overrides,
-    // so with none supplied the store is byte-identical to the table.
+    // The player option store, options_init_defaults whole (option.c L186-205,
+    // called from player_init at player.c:491). In upstream's order:
+    //
+    //   1. every option from its table `normal` (OPTION_ENTRIES),
+    //   2. the player's customised BIRTH defaults from ANGBAND_DIR_USER,
+    //   3. their customised INTERFACE defaults,
+    //   4. delay_factor = 40 and hitpoint_warn = 3,
+    //
+    // and only then this call's explicit birth/interface CHOICES on top. Steps 2
+    // and 3 read customized_<page>_options.txt through the installed host; with
+    // no host, or no such file, they are exactly the table defaults, which is why
+    // a test or an MCP session sees no change. Built before level generation so
+    // birth_randarts can swap the artifact set first.
+    const initial = optionsInitDefaults(host());
     const options = new OptionState({
-        ...(opts.optionOverrides ? { overrides: opts.optionOverrides } : {}),
-        ...(opts.hitpointWarn !== undefined ? { hitpointWarn: opts.hitpointWarn } : {}),
+        overrides: { ...initial.opts, ...(opts.optionOverrides ?? {}) },
+        hitpointWarn: opts.hitpointWarn ?? initial.hitpointWarn,
+        delayFactor: initial.delayFactor,
     });
     // options_init_cheat (player-birth.c:1234, gap 1.12): at character accept,
     // clear every cheat option and its score twin, THEN re-apply the port-only
@@ -2160,6 +2537,10 @@ export function startGame(pack, opts = {}) {
         speed: pstate.speed,
         totalEnergy: 0,
         combat,
+        /* p->known_state, seeded with the real state and replaced with the true
+         * known derive at the end of wireGame - the flavour store and the rune env
+         * it needs do not exist yet at this line. */
+        knownCombat: combat,
         defense: toDefenderState(pstate),
         weapon,
         stealth: combat.skills[SKILL.STEALTH] ?? 0,
@@ -2194,6 +2575,12 @@ export function startGame(pack, opts = {}) {
         /* birth_levels_persist (#30) frozen-level cache; empty until a level is
          * left with the option on (the whole persist path is option-gated). */
         levelCache: new Map(),
+        /* The STARTING level's stair connectors, on the same option gate
+         * changeLevel uses. Without this the first level a character ever stands on
+         * freezes with an empty join list and its neighbour cannot align to it. */
+        ...((options.get("birth_levels_persist") ?? false)
+            ? { currentJoins: [...booted.joins] }
+            : {}),
         turn: 0,
         z: {
             ...DEFAULT_GAME_CONSTANTS,
@@ -2211,6 +2598,17 @@ export function startGame(pack, opts = {}) {
         },
         brands: reg.objects.brands,
         slays: reg.objects.slays,
+        curses: reg.objects.curses,
+        /* player_has_temporary_brand / _slay (player-util.c), bound ONCE here from the
+         * pack's timed records. The melee hooks used to build a private copy and
+         * nothing else could reach one, so obj-info's brand/slay gathering carried a
+         * "DEFERRED" note beside a predicate that already existed - PORT_TODO 3.20. */
+        tempBrandSlay: buildTempBrandSlay(birth.player, 
+        /* The RAW pack records, not players.timed - bindPlayer's TimedEffect has no
+         * brand/slay code arrays, so passing the bound table silently mapped every
+         * index to -1 and hasBrand answered false for everything. Measured: the
+         * first draft of this did exactly that and the test caught it. */
+        pack.player.timed, reg.objects.brands, reg.objects.slays),
         /* Placeholder; wireGame installs the full registry-backed env. */
         runeEnv: makeRuneEnv(() => null, () => false),
         playing: true,
@@ -2223,7 +2621,7 @@ export function startGame(pack, opts = {}) {
     // seed_flavor already drawn above; flavor_init runs inside wireGame.
     if (opts.updateFov)
         state.updateFov = opts.updateFov;
-    const wired = wireGame(state, reg, players, pstate, seedFlavor, pack);
+    const wired = wireGame(state, reg, players, pstate, seedFlavor);
     /* PU_INVEN from the starting kit's inven_carry (player-birth.c). */
     buildGearViews(state, reg, pstate.ammoTval);
     // kind->everseen = true for each bought start item (player-birth.c L658). At
@@ -2240,6 +2638,13 @@ export function startGame(pack, opts = {}) {
     for (const kind of startKinds) {
         wired.flavor.objectFlavorAware(kind, NOOP_FLAVOR_AWARE_DEPS);
     }
+    // obj->known->effect = obj->effect per start item (player-birth.c:650). The
+    // objectFlavorAware pass above already covers every kind the outfit can
+    // contain, so this is the C's line rather than a behaviour change - but it is
+    // the line, and the field now exists to hold it.
+    for (const obj of state.gear.store.values()) {
+        obj.knownEffect = obj.effect;
+    }
     // birth_know_runes (player-birth.c L1261-1262): a birth_know_runes character
     // knows every rune for ID-on-walkover (gap 1.5). No RNG. Before
     // player_learn_innate, matching the C acceptance order.
@@ -2301,6 +2706,10 @@ export function startGame(pack, opts = {}) {
     state.chunk.onlyPartial = true;
     if (state.updateFov) {
         state.updateFov(state);
+        /* on_new_level's own disturb (game-world.c:1016-1017), immediately before
+         * the feeling and the search: arriving on a level cancels whatever was
+         * still queued from the level you left. */
+        disturb(state);
         announceFeeling(state, reg);
         search(state); /* on_new_level (game-world.c:1052). */
         state.chunk.onlyPartial = false;
@@ -2348,6 +2757,10 @@ function makeStoreApi(state, reg, flavor, options) {
         },
         maxDepth: state.actor.player.maxDepth,
         stores: state.stores ?? [],
+        /* The sell path decides through storeWillBuy too, so it reads the same
+         * registry the maintenance path does - a seam supplied to every path but
+         * one is the shape that lets a mod work in town and not in the shop. */
+        ...(state.storeBehaviour ? { behaviour: state.storeBehaviour } : {}),
     });
     const noSelling = () => options.get("birth_no_selling") ?? false;
     /* update_stuff's PU_INVEN after a gear change (obj-gear.c: inven_carry /
@@ -2369,11 +2782,25 @@ function makeStoreApi(state, reg, flavor, options) {
             msg: (text) => state.msg?.(text),
         });
     };
+    /**
+     * object_flag_is_known(player, obj, flag) bound to one object, for
+     * store_will_buy's buy-list branch (store.c:551). PORT_TODO 2.10 / 5.8.
+     *
+     * The shadow is synthesised ONCE per object rather than per flag: a buy list
+     * can name several flags for one tval, and objectKnownShadow walks the whole
+     * rune set each time it is called.
+     */
+    const flagKnownFor = (obj) => {
+        const p = state.actor.player;
+        const shadow = objectKnownShadow(obj, p, state.runeEnv, knownDescOf(state));
+        return (flag) => objectFlagIsKnown(obj, shadow, p, state.runeEnv, flag);
+    };
     const txnKnow = (obj) => ({
         flavor,
         flavorDeps: flavorAwareDeps(state),
         aware: flavor.isAware(obj.kind),
         noSelling: noSelling(),
+        flagKnown: flagKnownFor(obj),
         /* do_cmd_sell L1946-1951: selling teaches the runes as well as the flavour.
          * buildRuneList is rebuilt per call for the same reason effect-item.ts does
          * it (L930): a mod can add runes mid-session, so a cached list would go
@@ -2385,7 +2812,7 @@ function makeStoreApi(state, reg, flavor, options) {
             /* do_cmd_retrieve (store.c:1783): Home Take is free - no price, no
              * ORIGIN_STORE, no shuffle/maint RNG. Reuse the existing homeRetrieve. */
             if (store.feat === FEAT.HOME) {
-                const r = homeRetrieve(store, obj, amt, state.gear, reg.constants);
+                const r = homeRetrieve(store, obj, amt, state.actor.player, state.gear, reg.constants);
                 if (!r.ok) {
                     return {
                         ok: false,
@@ -2425,7 +2852,15 @@ function makeStoreApi(state, reg, flavor, options) {
             const obj = state.gear.store.get(handle);
             const know = obj
                 ? txnKnow(obj)
-                : { flavor, flavorDeps: flavorAwareDeps(state), aware: false, noSelling: noSelling() };
+                : {
+                    flavor,
+                    flavorDeps: flavorAwareDeps(state),
+                    aware: false,
+                    noSelling: noSelling(),
+                    /* No object behind the handle, so the sale is refused before the
+                     * buy list is consulted; nothing can be known about a flag on it. */
+                    flagKnown: () => false,
+                };
             const result = storeSell(storeCtx(), store, handle, amt, state.actor.player, state.gear, know);
             /* do_cmd_sell: selling an artifact reveals it (history_find_artifact,
              * store.c L1928); if the store then discards it, it is lost (L1992). */
@@ -2481,7 +2916,7 @@ function makeStoreApi(state, reg, flavor, options) {
         price: (store, obj, storeBuying, qty) => priceItem(reg.objects, store, store.owner, obj, storeBuying, qty, flavor.isAware(obj.kind), noSelling()),
         /* runesKnown matches storeSell's know (txnKnow never sets it, so the
          * transaction treats it as false); keep the filter aligned with the sale. */
-        willBuy: (store, obj) => storeWillBuy(reg.objects, store, obj, flavor.isAware(obj.kind), noSelling(), false),
+        willBuy: (store, obj) => storeWillBuy(reg.objects, store, obj, flavor.isAware(obj.kind), noSelling(), false, flagKnownFor(obj), state.storeBehaviour),
     };
 }
 /**
@@ -2533,7 +2968,7 @@ function swapRandartSet(reg, seed, timedFoil, activationSummarize) {
      * (gap 3.8, effect_summarize_properties) is threaded via activationSummarize
      * so remove_contradictory_activation can drop a redundant activation
      * (obj-randart.c L2420); absent, it stays a conservative no-op. */
-    const randarts = doRandart(reg.objects, seed, reg.nameSections.get(RANDNAME_TOLKIEN), timedFoil || activationSummarize
+    const randarts = doRandart(reg.objects, reg.constants, seed, true, reg.nameSections.get(RANDNAME_TOLKIEN), timedFoil || activationSummarize
         ? { timedFoil, activationSummarize }
         : undefined);
     reg.objects.artifacts.length = 0;
@@ -2635,8 +3070,16 @@ export function loadGame(pack, saveDocument, present = new Set(["core"]), opts =
     if (!save.chunk && save.dungeonDepth !== undefined) {
         chunk.depth = save.dungeonDepth;
     }
-    const player = deserializePlayer(save.player, players, reg.objects, ids);
+    const player = deserializePlayer(save.player, players, reg.objects, ids, reg.quests);
     const gear = deserializeGear(save.gear, reg.objects, ids);
+    /* rd_gear (load.c L1179-1185): the carried-weight total is RE-SUMMED from the
+     * restored gear, not trusted from the file. Upstream does this because its
+     * gear list and the total are written separately; the port needs it for a
+     * second reason - a character saved before this accounting existed carries a
+     * stored total of 0, and reading that back would leave them weightless for
+     * the rest of the game. It has to run before calcBonuses below, which reads
+     * the total for the carrying-capacity speed penalty. */
+    player.upkeep.totalWeight = gearTotalWeight(gear);
     const equipment = player.equipment.map((h) => (h ? gearGet(gear, h) : null));
     const weaponSlot = player.body.slots.findIndex((s) => s.type === "WEAPON");
     const weapon = weaponSlot >= 0 ? (equipment[weaponSlot] ?? null) : null;
@@ -2662,6 +3105,10 @@ export function loadGame(pack, saveDocument, present = new Set(["core"]), opts =
         speed: pstate.speed,
         totalEnergy: save.actor.totalEnergy,
         combat,
+        /* p->known_state, seeded with the real state and replaced with the true
+         * known derive at the end of wireGame - the flavour store and the rune env
+         * it needs do not exist yet at this line. */
+        knownCombat: combat,
         defense: toDefenderState(pstate),
         weapon,
         stealth: combat.skills[SKILL.STEALTH] ?? 0,
@@ -2675,6 +3122,11 @@ export function loadGame(pack, saveDocument, present = new Set(["core"]), opts =
             decoy = grid;
         })
         : new Map();
+    /* Hoisted: the remembered pile is saved as locators into these very piles,
+     * so deserializeKnown must be handed the same map the state runs on. */
+    const loadedFloor = !save.isDead && save.floor
+        ? deserializeFloor(save.floor, reg.objects, chunk.width, ids)
+        : new Map();
     const state = {
         rng,
         chunk,
@@ -2683,13 +3135,11 @@ export function loadGame(pack, saveDocument, present = new Set(["core"]), opts =
         decoy,
         monsters: (save.isDead ? [null] : (save.monsters ?? [null])).map((m) => m ? deserializeMonster(m, reg.monsters, reg.objects, ids) : null),
         groups: (save.isDead ? [null] : (save.groups ?? [null])).map((g) => g ? { index: g.index, leader: g.leader, members: [...g.members] } : null),
-        floor: !save.isDead && save.floor
-            ? deserializeFloor(save.floor, reg.objects, chunk.width, ids)
-            : new Map(),
+        floor: loadedFloor,
         traps: loadedTraps,
         known: save.isDead
             ? newKnownMap(chunk.width, chunk.height)
-            : deserializeKnown(save.known, chunk.width, chunk.height, featRemap),
+            : deserializeKnown(save.known, chunk.width, chunk.height, featRemap, ids, loadedFloor, reg.objects),
         /* birth_levels_persist (#30) frozen-level cache; empty in saves written
          * before the field or with the option off (back-compat). */
         levelCache: deserializeLevelCache(save.isDead ? undefined : save.levelCache, reg.features, reg.monsters, reg.objects, reg.traps, ids),
@@ -2770,6 +3220,17 @@ export function loadGame(pack, saveDocument, present = new Set(["core"]), opts =
         },
         brands: reg.objects.brands,
         slays: reg.objects.slays,
+        curses: reg.objects.curses,
+        /* player_has_temporary_brand / _slay (player-util.c), bound ONCE here from the
+         * pack's timed records. The melee hooks used to build a private copy and
+         * nothing else could reach one, so obj-info's brand/slay gathering carried a
+         * "DEFERRED" note beside a predicate that already existed - PORT_TODO 3.20. */
+        tempBrandSlay: buildTempBrandSlay(player, 
+        /* The RAW pack records, not players.timed - bindPlayer's TimedEffect has no
+         * brand/slay code arrays, so passing the bound table silently mapped every
+         * index to -1 and hasBrand answered false for everything. Measured: the
+         * first draft of this did exactly that and the test caught it. */
+        pack.player.timed, reg.objects.brands, reg.objects.slays),
         /* Placeholder; wireGame installs the full registry-backed env. */
         runeEnv: makeRuneEnv(() => null, () => false),
         playing: save.playing,
@@ -2805,16 +3266,27 @@ export function loadGame(pack, saveDocument, present = new Set(["core"]), opts =
         player.noscore = markNoscore(player.noscore, NOSCORE.WIZARD);
         state.isDead = false;
     }
-    /* A save taken in single combat resumes it (the stashed pre-arena
-     * level is gone: winning exits to a fresh level of the same depth). */
+    /* A save taken in single combat resumes it, INCLUDING the level it was
+     * entered from - upstream keeps that in the chunk_list and the savefile
+     * carries it. Rebuilt through the frozen-level cache deserializer, which is
+     * the same code path the live level and the persistent cache use. A save
+     * written before the stash was persisted has no `stash` key and reloads with
+     * the old behaviour: winning exits to a fresh level of the same depth. */
     if (save.arena) {
         state.arenaLevel = true;
         state.oldGrid = loc(save.arena.oldGrid.x, save.arena.oldGrid.y);
+        if (save.arena.stash) {
+            const rebuilt = deserializeLevelCache([save.arena.stash], reg.features, reg.monsters, reg.objects, reg.traps, ids);
+            const level = rebuilt.get(save.arena.stash.depth);
+            if (level) {
+                state.arenaStash = { ...level, monMidx: save.arena.monMidx ?? 0 };
+            }
+        }
     }
     /* seed_flavor from the save (load.c L960). Older saves predate it; fall
      * back to 0 so flavor_init still produces a stable per-load assignment. */
     const seedFlavor = save.seedFlavor ?? 0;
-    const wired = wireGame(state, reg, players, pstate, seedFlavor, pack);
+    const wired = wireGame(state, reg, players, pstate, seedFlavor);
     /* rd_gear's tail (load.c:1187). */
     buildGearViews(state, reg, pstate.ammoTval);
     /* restore() replaces the aware/tried sets, so it must run AFTER flavor_init's
@@ -2851,6 +3323,10 @@ export function loadGame(pack, saveDocument, present = new Set(["core"]), opts =
     const booted = {
         chunk,
         depth: chunk.depth,
+        /* The restored level's connectors live on state.currentJoins, which the
+         * savefile already carries; this view describes a level nothing
+         * generated, so it reports none. */
+        joins: [],
         playerSpot: actor.grid,
         monsters: [],
         objects: [],