@rpgm-tools/neo-angband-core 0.10.0

package/dist/gen/cave.js

@@ -0,0 +1,2406 @@
+/**
+ * Dungeon (cave) builders, tunneling, connectivity, mineral streamers and the
+ * runtime-registrable dungeon-profile registry, ported from
+ * reference/src/gen-cave.c and the profile-selection code of generate.c
+ * (Angband 4.2.6).
+ *
+ * PORTED: classic_gen and modified_gen (with do_traditional_tunneling,
+ * build_tunnel, choose_random_entrance, build_streamer, ensure_connectedness
+ * and handle_level_stairs), and choose_profile's selection by depth.
+ *
+ * MODDABILITY (ratified pillar, decision 13): cave builders live in a
+ * string-keyed registry and dungeon profiles in a runtime-registrable list.
+ * A mod can register a new builder key and add a profile that uses it.
+ *
+ * PORTED (standalone): labyrinth_gen and cavern_gen (with labyrinth_chunk's
+ * Kruskal maze, and init_cavern/mutate_cavern/clear_small_regions/cavern_chunk's
+ * cellular automaton). cavern_chunk's persistent-level `join` stair machinery is
+ * ported but dormant (dun.join is empty for non-persistent levels).
+ *
+ * PORTED (multi-region): moria_gen (modified-style with the moria profile +
+ * "Moria dwellers" restriction), lair_gen (a modified half joined to a themed
+ * cavern), gauntlet_gen (two caverns split by an unmappable labyrinth) and
+ * hard_centre_gen (a greater vault surrounded by four caverns), with the
+ * chunk_copy merge helper, connect_caverns and vault_chunk (room.ts). All four
+ * builder keys (moria/lair/gauntlet/hard_centre) are registered AND selectable:
+ * choose() runs the same weighted profile loop as choose_profile (generate.c
+ * L866-878), so any profile with alloc > 0 - moria and the multi-region
+ * builders included - is picked by depth exactly as upstream.
+ *
+ * DEFERRED: the town builder's full store generation and persistent-level
+ * connectors remain deferred. The single-combat arena level is generated in
+ * the session layer (session/game.ts, matching arena_gen at gen-cave.c:3984),
+ * as upstream also special-cases it outside the normal builder loop.
+ */
+import { DUN_PROFILE_ENTRIES, FEAT, ORIGIN, ROOM_ENTRIES, SQUARE } from "../generated/index.js";
+import { DDGRID_DDD, loc, locSum } from "../loc.js";
+import { Chunk, featIsBright } from "../world/chunk.js";
+import { roomBuild, symmetryTransform, vaultChunk } from "./room.js";
+import { monRestrict, setPitType, spreadMonsters } from "./gen-monster.js";
+import { CaveFinder, Dun, Gen, allocObjects, allocStairs, caveFind, caveFindInRange, correctDir, countNeighbors, drawRectangle, fillRectangle, findNearbyGrid, generateMark, generateStarburstRoom, gridToI, iToGrid, newPlayerSpot, nextGrid, pickAndPlaceDistantMonster, placeClosedDoor, placeRandomDoor, placeTrap, randDir, setMarkedGranite, shuffle, squareIsEmpty, squareIsGraniteWithFlag, squareIswallOuter, squareIsRoom, squareIsStrongWall, SET_BOTH, SET_CORR, SET_ROOM, TYP_GOLD, TYP_GOOD, TYP_GREAT, TYP_OBJECT, TYP_RUBBLE, TYP_TRAP, DIR_N, DIR_S, DIR_E, DIR_W, DIR_SE, distance, } from "./util.js";
+const ZERO_TUNNEL = { rnd: 0, chg: 0, con: 0, pen: 0, jct: 0 };
+const ZERO_STREAMER = {
+    den: 0,
+    rng: 0,
+    mag: 0,
+    mc: 0,
+    qua: 0,
+    qc: 0,
+};
+/**
+ * name -> cave builder key, from list-dun-profiles.h. The port's stand-in for
+ * get_level_profile_index_from_name (generate.c L1600): the C resolves a profile
+ * name to its index in cave_profiles[] and indexes the builder from there, while
+ * DUN_PROFILE_ENTRIES carries the name->builder pairing directly.
+ * get_level_profile_name_from_index (generate.c L1612) is the inverse and is
+ * DUN_PROFILE_ENTRIES[i].name; both C functions exist only for wiz-stats.c's
+ * level dumps, never for the savefile.
+ */
+function profileBuilderKey(name) {
+    for (const e of DUN_PROFILE_ENTRIES) {
+        if (e.name === name)
+            return e.builder;
+    }
+    throw new Error(`gen: unknown dungeon profile name '${name}'`);
+}
+/**
+ * room name -> room-builder key, from list-rooms.h. This is
+ * get_room_builder_index_from_name (generate.c L1570) plus the room_builders[i]
+ * .builder deref that parse_profile_room (generate.c L171-177) does with it;
+ * get_room_builder_name_from_index (L1590) is ROOM_ENTRIES[i].name and
+ * get_room_builder_count (L1561) is ROOM_ENTRIES.length. The C trio is only
+ * consumed by wiz-stats.c, never by the savefile.
+ */
+function roomBuilderKey(name) {
+    for (const e of ROOM_ENTRIES) {
+        if (e.name === name)
+            return e.builder;
+    }
+    throw new Error(`gen: unknown room name '${name}'`);
+}
+/** Convert one dungeon_profile.json record into a DunProfile. */
+export function loadDunProfile(rec) {
+    const roomProfiles = (rec.room ?? []).map((r) => ({
+        name: r.name,
+        builder: roomBuilderKey(r.name),
+        rating: r.rating,
+        height: r.height,
+        width: r.width,
+        level: r.level,
+        pit: r.pit !== 0,
+        rarity: r.rarity,
+        cutoff: r.cutoff,
+    }));
+    return {
+        name: rec.name,
+        builder: profileBuilderKey(rec.name),
+        blockSize: rec.params.block,
+        dunRooms: rec.params.rooms,
+        dunUnusual: rec.params.unusual,
+        maxRarity: rec.params.rarity,
+        tun: rec.tunnel ?? ZERO_TUNNEL,
+        str: rec.streamer ?? ZERO_STREAMER,
+        roomProfiles,
+        minLevel: rec["min-level"] ?? 0,
+        alloc: rec.alloc,
+    };
+}
+/* ------------------------------------------------------------------ *
+ * choose_random_entrance (gen-cave.c).
+ * ------------------------------------------------------------------ */
+/**
+ * Randomly choose a marked entrance for room ridx, biased toward tgt, or
+ * loc(0, 0) when there is no satisfactory entrance.
+ */
+function chooseRandomEntrance(g, ridx, tgt, bias, exc) {
+    const dun = g.dun;
+    const nEnt = dun.entN[ridx] ?? 0;
+    if (nEnt > 0) {
+        const entries = dun.ent[ridx];
+        const accum = new Array(nEnt + 1).fill(0);
+        let nchoice = 0;
+        for (let i = 0; i < nEnt; i++) {
+            const e = entries[i];
+            let included = squareIsGraniteWithFlag(g.c, e, SQUARE.WALL_OUTER);
+            if (included) {
+                for (const x of exc) {
+                    const dx = e.x - x.x;
+                    const dy = e.y - x.y;
+                    if (Math.abs(dx) <= 1 && Math.abs(dy) <= 1 && (dx !== 0 || dy !== 0)) {
+                        included = false;
+                        break;
+                    }
+                }
+            }
+            if (included) {
+                if (tgt) {
+                    const d = distance(e, tgt);
+                    if (d === 0)
+                        return e;
+                    const biased = Math.max(1, bias - d);
+                    accum[i + 1] = accum[i] + biased * biased;
+                }
+                else {
+                    accum[i + 1] = accum[i] + 1;
+                }
+                nchoice++;
+            }
+            else {
+                accum[i + 1] = accum[i];
+            }
+        }
+        if (nchoice > 0) {
+            const chosen = g.rng.randint0(accum[nEnt]);
+            let low = 0;
+            let high = nEnt;
+            for (;;) {
+                if (low === high - 1)
+                    return entries[low];
+                const mid = low + Math.trunc((high - low) / 2);
+                if (accum[mid] <= chosen)
+                    low = mid;
+                else
+                    high = mid;
+            }
+        }
+    }
+    return loc(0, 0);
+}
+/* ------------------------------------------------------------------ *
+ * build_tunnel (gen-cave.c).
+ * ------------------------------------------------------------------ */
+function pierceOuterWall(g, grid) {
+    const dun = g.dun;
+    if (dun.wallN < dun.wallPierceMax) {
+        dun.wall[dun.wallN] = grid;
+        dun.wallN++;
+    }
+    for (let ay = grid.y - 1; ay <= grid.y + 1; ay++) {
+        for (let ax = grid.x - 1; ax <= grid.x + 1; ax++) {
+            const adj = loc(ax, ay);
+            if (ax !== 0 &&
+                ay !== 0 &&
+                g.c.inBounds(adj) &&
+                squareIsGraniteWithFlag(g.c, adj, SQUARE.WALL_OUTER)) {
+                setMarkedGranite(g.c, adj, SQUARE.WALL_SOLID);
+            }
+        }
+    }
+}
+function handlePostWallStep(g, grid, st) {
+    let cur = grid;
+    const dir = st.offset;
+    if (dir.x !== 0 && dir.y !== 0) {
+        cur = loc(cur.x + dir.x, cur.y + dir.y);
+        if (!squareIsRoom(g.c, cur) && g.c.isGranite(cur)) {
+            if (g.dun.tunnN < g.dun.tunnGridMax) {
+                g.dun.tunn[g.dun.tunnN] = cur;
+                g.dun.tunnN++;
+            }
+            st.door = false;
+        }
+        st.bend = 0;
+        if (g.rng.randint0(32768) < 16384)
+            st.offset = loc(0, dir.y);
+        else
+            st.offset = loc(dir.x, 0);
+    }
+    else {
+        st.bend = 1;
+    }
+    return cur;
+}
+function findNormalToWall(g, grid, inner) {
+    const choices = [];
+    let ncardinal = 0;
+    const ddd = ddgridDdd();
+    for (let i = 0; i < 8; i++) {
+        const off = ddd[i];
+        const chk = loc(grid.x + off.x, grid.y + off.y);
+        if (g.c.inBounds(chk) &&
+            !g.c.isPerm(chk) &&
+            squareIsRoom(g.c, chk) === inner &&
+            !squareIsGraniteWithFlag(g.c, chk, SQUARE.WALL_OUTER) &&
+            !squareIsGraniteWithFlag(g.c, chk, SQUARE.WALL_SOLID) &&
+            !squareIsGraniteWithFlag(g.c, chk, SQUARE.WALL_INNER)) {
+            choices.push(off);
+            if (i < 4)
+                ncardinal++;
+        }
+    }
+    let n = choices.length;
+    if (n > 1 && ncardinal > 0)
+        n = ncardinal;
+    return n === 0 ? loc(0, 0) : choices[g.rng.randint0(n)];
+}
+function allowsWallPiercingDoor(g, grid) {
+    let nOut = 0;
+    let nIn = 0;
+    for (let cy = grid.y - 1; cy <= grid.y + 1; cy++) {
+        for (let cx = grid.x - 1; cx <= grid.x + 1; cx++) {
+            if ((cy === 0 && cx === 0) || !g.c.inBounds(loc(cx, cy)))
+                continue;
+            const chk = loc(cx, cy);
+            if ((g.c.isPassable(chk) || g.c.isRubble(chk)) &&
+                !g.c.isDoor(chk) &&
+                !g.c.isShop(chk)) {
+                if (squareIsRoom(g.c, chk))
+                    nIn++;
+                else
+                    nOut++;
+            }
+        }
+    }
+    return nOut > 0 && nIn > 0;
+}
+let cachedDddGrid = null;
+function ddgridDdd() {
+    if (!cachedDddGrid) {
+        /* ddgrid_ddd order: S, N, E, W, SE, SW, NE, NW. */
+        cachedDddGrid = [
+            loc(0, 1),
+            loc(0, -1),
+            loc(1, 0),
+            loc(-1, 0),
+            loc(1, 1),
+            loc(-1, 1),
+            loc(1, -1),
+            loc(-1, -1),
+            loc(0, 0),
+        ];
+    }
+    return cachedDddGrid;
+}
+function buildTunnel(g, from, to) {
+    const dun = g.dun;
+    const c = g.c;
+    let grid1 = from;
+    let grid2 = to;
+    const start = grid1;
+    let mainLoop = 0;
+    const st = { door: false, bend: 0, offset: correctDir(g.rng, grid1, grid2) };
+    dun.tunnN = 0;
+    dun.wallN = 0;
+    while (!(grid1.x === grid2.x && grid1.y === grid2.y)) {
+        if (mainLoop++ > 2000)
+            break;
+        if (st.bend === 0) {
+            if (g.rng.randint0(100) < g.profileTun.chg) {
+                st.offset = correctDir(g.rng, grid1, grid2);
+                if (g.rng.randint0(100) < g.profileTun.rnd)
+                    st.offset = randDir(g.rng);
+            }
+        }
+        else {
+            st.bend--;
+        }
+        let tmp = loc(grid1.x + st.offset.x, grid1.y + st.offset.y);
+        while (!c.inBounds(tmp)) {
+            st.offset = correctDir(g.rng, grid1, grid2);
+            if (g.rng.randint0(100) < g.profileTun.rnd)
+                st.offset = randDir(g.rng);
+            tmp = loc(grid1.x + st.offset.x, grid1.y + st.offset.y);
+        }
+        if ((c.isPerm(tmp) && !c.sqinfoHas(tmp, SQUARE.WALL_INNER)) ||
+            squareIsGraniteWithFlag(c, tmp, SQUARE.WALL_SOLID)) {
+            continue;
+        }
+        if (squareIsGraniteWithFlag(c, tmp, SQUARE.WALL_OUTER)) {
+            const nxt = loc(grid2.x - tmp.x, grid2.y - tmp.y);
+            if (nxt.x === 0 && nxt.y === 0) {
+                grid1 = tmp;
+                pierceOuterWall(g, grid1);
+                continue;
+            }
+            if (Math.abs(nxt.x) <= 1 &&
+                Math.abs(nxt.y) <= 1 &&
+                squareIsGraniteWithFlag(c, grid2, SQUARE.WALL_OUTER)) {
+                continue;
+            }
+            const iroom = dun.ent2room[tmp.y * c.width + tmp.x];
+            if (iroom !== -1) {
+                let nxtdir;
+                if (squareIsRoom(c, grid1)) {
+                    nxtdir = findNormalToWall(g, tmp, false);
+                    if (nxtdir.x === 0 && nxtdir.y === 0)
+                        continue;
+                    grid1 = tmp;
+                    pierceOuterWall(g, grid1);
+                }
+                else {
+                    let bias = 80 -
+                        Math.trunc((80 *
+                            Math.min(Math.max(0, g.profileTun.chg), 100) *
+                            Math.min(Math.max(0, g.profileTun.rnd), 100)) /
+                            10000);
+                    let ntry = 0;
+                    const mtry = 20;
+                    const exc = [tmp, grid2];
+                    let chk = loc(0, 0);
+                    nxtdir = loc(0, 0);
+                    for (;;) {
+                        if (ntry >= mtry)
+                            break;
+                        chk = chooseRandomEntrance(g, iroom, grid2, bias, exc);
+                        if (chk.x === 0 && chk.y === 0) {
+                            ntry = mtry;
+                            break;
+                        }
+                        nxtdir = findNormalToWall(g, chk, false);
+                        if (nxtdir.x !== 0 || nxtdir.y !== 0)
+                            break;
+                        ntry++;
+                        bias = Math.trunc((bias * 8) / 10);
+                    }
+                    if (ntry >= mtry)
+                        continue;
+                    pierceOuterWall(g, tmp);
+                    pierceOuterWall(g, chk);
+                    grid1 = chk;
+                }
+                st.offset = nxtdir;
+                grid1 = handlePostWallStep(g, grid1, st);
+                continue;
+            }
+            const nxtdir = findNormalToWall(g, tmp, !squareIsRoom(c, grid1));
+            if (nxtdir.x === 0 && nxtdir.y === 0)
+                continue;
+            grid1 = tmp;
+            pierceOuterWall(g, grid1);
+            st.offset = nxtdir;
+            grid1 = handlePostWallStep(g, grid1, st);
+        }
+        else if (squareIsRoom(c, tmp)) {
+            grid1 = tmp;
+        }
+        else if (c.isGranite(tmp)) {
+            grid1 = tmp;
+            if (dun.tunnN < dun.tunnGridMax) {
+                dun.tunn[dun.tunnN] = grid1;
+                dun.tunnN++;
+            }
+            st.door = false;
+        }
+        else {
+            grid1 = tmp;
+            if (!st.door) {
+                if (dun.doorN < dun.levelDoorMax) {
+                    dun.door[dun.doorN] = grid1;
+                    dun.doorN++;
+                }
+                st.door = true;
+            }
+            if (g.rng.randint0(100) >= g.profileTun.con) {
+                const d = loc(grid1.x - start.x, grid1.y - start.y);
+                if (Math.abs(d.x) > 10 || Math.abs(d.y) > 10)
+                    break;
+            }
+        }
+    }
+    for (let i = 0; i < dun.tunnN; i++)
+        c.setFeat(dun.tunn[i], FEAT.FLOOR);
+    for (let i = 0; i < dun.wallN; i++) {
+        const w = dun.wall[i];
+        c.setFeat(w, FEAT.FLOOR);
+        if (g.rng.randint0(100) < g.profileTun.pen && allowsWallPiercingDoor(g, w)) {
+            placeRandomDoor(g, w);
+        }
+    }
+}
+/* ------------------------------------------------------------------ *
+ * do_traditional_tunneling (gen-cave.c).
+ * ------------------------------------------------------------------ */
+function nextToCorr(g, grid) {
+    let k = 0;
+    const ddd = ddgridDdd();
+    for (let i = 0; i < 4; i++) {
+        const off = ddd[i];
+        const g1 = loc(grid.x + off.x, grid.y + off.y);
+        if (g.c.isFloor(g1) && !squareIsRoom(g.c, g1))
+            k++;
+    }
+    return k;
+}
+function possibleDoorway(g, grid) {
+    if (nextToCorr(g, grid) < 2)
+        return false;
+    if (squareIsStrongWall(g.c, nextGrid(grid, DIR_N)) &&
+        squareIsStrongWall(g.c, nextGrid(grid, DIR_S))) {
+        return true;
+    }
+    if (squareIsStrongWall(g.c, nextGrid(grid, DIR_W)) &&
+        squareIsStrongWall(g.c, nextGrid(grid, DIR_E))) {
+        return true;
+    }
+    return false;
+}
+function tryDoor(g, grid) {
+    if (!g.c.inBounds(grid))
+        return;
+    if (squareIsStrongWall(g.c, grid))
+        return;
+    if (squareIsRoom(g.c, grid))
+        return;
+    if (g.hasTrap(grid))
+        return;
+    if (g.c.isDoor(grid))
+        return;
+    if (g.rng.randint0(100) < g.profileTun.jct && possibleDoorway(g, grid)) {
+        placeRandomDoor(g, grid);
+    }
+    else if (g.rng.randint0(500) < g.profileTun.jct && possibleDoorway(g, grid)) {
+        /* place_trap(c, grid, -1, c->depth) (gen-cave.c:830-833): pick_trap +
+         * randcalc power on the generation stream, not a bare markTrap. */
+        placeTrap(g, grid);
+    }
+}
+function doTraditionalTunneling(g) {
+    const dun = g.dun;
+    const scrambled = [];
+    for (let i = 0; i < dun.centN; i++)
+        scrambled[i] = i;
+    for (let i = 0; i < dun.centN; i++) {
+        const p1 = g.rng.randint0(dun.centN);
+        const p2 = g.rng.randint0(dun.centN);
+        const t = scrambled[p1];
+        scrambled[p1] = scrambled[p2];
+        scrambled[p2] = t;
+    }
+    dun.doorN = 0;
+    if (dun.centN === 0)
+        return;
+    let grid = chooseRandomEntrance(g, scrambled[dun.centN - 1], null, 80, []);
+    if (grid.x === 0 && grid.y === 0) {
+        grid = dun.cent[scrambled[dun.centN - 1]];
+    }
+    for (let i = 0; i < dun.centN; i++) {
+        let next = chooseRandomEntrance(g, scrambled[i], grid, 80, []);
+        if (next.x === 0 && next.y === 0)
+            next = dun.cent[scrambled[i]];
+        buildTunnel(g, next, grid);
+        grid = next;
+    }
+    for (let i = 0; i < dun.doorN; i++) {
+        const d = dun.door[i];
+        tryDoor(g, nextGrid(d, DIR_W));
+        tryDoor(g, nextGrid(d, DIR_E));
+        tryDoor(g, nextGrid(d, DIR_N));
+        tryDoor(g, nextGrid(d, DIR_S));
+    }
+}
+/* ------------------------------------------------------------------ *
+ * build_streamer (gen-cave.c).
+ * ------------------------------------------------------------------ */
+function buildStreamer(g, feat, chance) {
+    const c = g.c;
+    let grid = loc(g.rng.randSpread(Math.trunc(c.width / 2), 15), g.rng.randSpread(Math.trunc(c.height / 2), 10));
+    const dirOff = ddgridDdd();
+    /* ddd[randint0(8)] chooses among S,N,E,W,SE,SW,NE,NW. */
+    const dir = dirOff[g.rng.randint0(8)];
+    for (;;) {
+        for (let i = 0; i < g.profileStr.den; i++) {
+            const d = g.profileStr.rng;
+            const change = findNearbyGrid(c, g.rng, grid, d, d);
+            if (change && (c.isMagma(change) || c.isQuartz(change) || c.isGranite(change))) {
+                c.setFeat(change, feat);
+                if (g.rng.oneIn(chance)) {
+                    /* square_upgrade_mineral: magma/quartz -> the treasure variant. */
+                    const cur = c.feat(change);
+                    if (cur === FEAT.MAGMA)
+                        c.setFeat(change, FEAT.MAGMA_K);
+                    else if (cur === FEAT.QUARTZ)
+                        c.setFeat(change, FEAT.QUARTZ_K);
+                }
+            }
+        }
+        grid = loc(grid.x + dir.x, grid.y + dir.y);
+        if (!c.inBounds(grid))
+            break;
+    }
+}
+/* ------------------------------------------------------------------ *
+ * ensure_connectedness (gen-cave.c flood-fill region joining).
+ * ------------------------------------------------------------------ */
+/**
+ * z-queue.c's `struct queue`, the FIFO the flood fills run on. Upstream's is a
+ * fixed-size ring that abort()s on overflow/underflow (q_new sizes it to the
+ * grid count); a growing array with a read cursor is the same FIFO order with
+ * no capacity to overflow.
+ */
+class IntQueue {
+    data = [];
+    head = 0;
+    /** q_push (z-queue.c:93). */
+    push(v) {
+        this.data.push(v);
+    }
+    /** q_pop (z-queue.c:99). */
+    pop() {
+        return this.data[this.head++];
+    }
+    get length() {
+        return this.data.length - this.head;
+    }
+}
+function ignorePoint(g, colors, grid) {
+    if (!g.c.inBounds(grid))
+        return true;
+    if (colors[grid.y * g.c.width + grid.x])
+        return true;
+    if (g.c.isPassable(grid))
+        return false;
+    if (g.c.isDoor(grid))
+        return false;
+    return true;
+}
+function buildColorPoint(g, colors, counts, grid, color, diagonal) {
+    const w = g.c.width;
+    const queue = new IntQueue();
+    const added = new Uint8Array(g.c.height * w);
+    queue.push(grid.y * w + grid.x);
+    counts[color] = 0;
+    const ddd = ddgridDdd();
+    const nDir = diagonal ? 8 : 4;
+    while (queue.length > 0) {
+        const n1 = queue.pop();
+        const g1 = loc(n1 % w, Math.trunc(n1 / w));
+        if (ignorePoint(g, colors, g1))
+            continue;
+        colors[n1] = color;
+        counts[color] = counts[color] + 1;
+        for (let i = 0; i < nDir; i++) {
+            const off = ddd[i];
+            const g2 = loc(g1.x + off.x, g1.y + off.y);
+            const n2 = g2.y * w + g2.x;
+            if (ignorePoint(g, colors, g2))
+                continue;
+            if (added[n2])
+                continue;
+            queue.push(n2);
+            added[n2] = 1;
+        }
+    }
+}
+/**
+ * build_colors: colour every NESW- (or, when `diagonal`, 8-)contiguous region.
+ * The port's long-standing callers (ensureConnectedness, cavernChunk) pass
+ * `diagonal = false`; connect_caverns passes `true` to match gen-cave.c.
+ */
+function buildColors(g, colors, counts, diagonal) {
+    let color = 1;
+    for (let y = 0; y < g.c.height; y++) {
+        for (let x = 0; x < g.c.width; x++) {
+            if (ignorePoint(g, colors, loc(x, y)))
+                continue;
+            buildColorPoint(g, colors, counts, loc(x, y), color, diagonal);
+            color++;
+        }
+    }
+}
+function countColors(counts) {
+    let num = 0;
+    for (const v of counts)
+        if (v > 0)
+            num++;
+    return num;
+}
+function firstColor(counts) {
+    for (let i = 0; i < counts.length; i++)
+        if (counts[i] > 0)
+            return i;
+    return -1;
+}
+function fixColors(colors, counts, from, to) {
+    for (let i = 0; i < colors.length; i++)
+        if (colors[i] === from)
+            colors[i] = to;
+    counts[to] = counts[to] + counts[from];
+    counts[from] = 0;
+}
+/**
+ * join_region: tunnel `color`'s region to a neighbouring region. With
+ * `newColorArg === -1` (the default used by ensureConnectedness/cavernChunk)
+ * any nearest neighbour is accepted; connect_caverns passes a specific target
+ * colour to join two named caverns, matching gen-cave.c.
+ */
+function joinRegion(g, colors, counts, color, newColorArg, allowVaultDisconnect) {
+    const w = g.c.width;
+    const size = g.c.height * w;
+    const queue = new IntQueue();
+    const previous = new Int32Array(size).fill(-1);
+    let newColor = newColorArg;
+    for (let i = 0; i < size; i++) {
+        if (colors[i] === color) {
+            queue.push(i);
+            previous[i] = i;
+        }
+    }
+    const ddd = ddgridDdd();
+    while (queue.length > 0) {
+        const n1 = queue.pop();
+        const color2 = colors[n1];
+        if (newColor === -1 && color2 && color2 !== color)
+            newColor = color2;
+        if (color2 === newColor) {
+            let n = n1;
+            while (colors[n] !== color) {
+                const grid = loc(n % w, Math.trunc(n / w));
+                if (colors[n] > 0)
+                    counts[colors[n]] = counts[colors[n]] - 1;
+                counts[color] = counts[color] + 1;
+                colors[n] = color;
+                if (!g.c.isPerm(grid) &&
+                    !g.c.sqinfoHas(grid, SQUARE.VAULT) &&
+                    !(g.c.isPassable(grid) || g.c.isDoor(grid))) {
+                    g.c.setFeat(grid, FEAT.FLOOR);
+                }
+                n = previous[n];
+            }
+            fixColors(colors, counts, newColor, color);
+            break;
+        }
+        for (let i = 0; i < 4; i++) {
+            const off = ddd[i];
+            const grid = loc((n1 % w) + off.x, Math.trunc(n1 / w) + off.y);
+            if (!g.c.inBounds(grid))
+                continue;
+            const n2 = grid.y * w + grid.x;
+            if (previous[n2] >= 0)
+                continue;
+            if (g.c.isPerm(grid))
+                continue;
+            if (g.c.sqinfoHas(grid, SQUARE.VAULT) && !allowVaultDisconnect)
+                continue;
+            queue.push(n2);
+            previous[n2] = n1;
+        }
+    }
+}
+/** ensure_connectedness: colour regions, then join until one remains. */
+export function ensureConnectedness(g, allowVaultDisconnect) {
+    const size = g.c.height * g.c.width;
+    const colors = new Int32Array(size);
+    const counts = new Int32Array(size);
+    buildColors(g, colors, counts, false);
+    let num = countColors(counts);
+    while (num > 1) {
+        const color = firstColor(counts);
+        joinRegion(g, colors, counts, color, -1, allowVaultDisconnect);
+        num--;
+    }
+}
+/**
+ * connect_caverns (gen-cave.c L3249): join the four caverns that surround the
+ * hard-centre vault. `floor` holds one sample floor grid from each cavern in
+ * the order [left, upper, lower, right]. NEW helper.
+ */
+export function connectCaverns(g, floor) {
+    const size = g.c.height * g.c.width;
+    const colors = new Int32Array(size);
+    const counts = new Int32Array(size);
+    const colorOfFloor = [0, 0, 0, 0];
+    /* Colour the regions (diagonally, as upstream), find each cavern's colour. */
+    buildColors(g, colors, counts, true);
+    for (let i = 0; i < 4; i++) {
+        const spot = gridToI(floor[i], g.c.width);
+        colorOfFloor[i] = colors[spot];
+    }
+    /* Join left and upper, right and lower. */
+    joinRegion(g, colors, counts, colorOfFloor[0], colorOfFloor[1], false);
+    joinRegion(g, colors, counts, colorOfFloor[2], colorOfFloor[3], false);
+    /* Re-read the (upper, lower) colours after those joins, then join the two
+     * big caverns. */
+    for (let i = 1; i < 3; i++) {
+        const spot = gridToI(floor[i], g.c.width);
+        colorOfFloor[i] = colors[spot];
+    }
+    joinRegion(g, colors, counts, colorOfFloor[1], colorOfFloor[2], false);
+}
+/**
+ * chunk_copy (gen-chunk.c L345): copy the source chunk's terrain, sqinfo,
+ * objects, traps, monsters and player spot into `dest` at offset (y0, x0) with
+ * the given rotation (reflect is always false for these builders). Draws no
+ * RNG. Monster indices are reassigned in `dest`; unique tracking transfers via
+ * attachMonster. NEW helper.
+ *
+ * NOTE: because each sub-chunk is a distinct Gen with its own unique-tracking,
+ * a unique could in principle be picked into two sibling sub-chunks before they
+ * are merged (upstream tracks r_info->cur_num globally). This is RNG-neutral
+ * and a pre-existing consequence of the port's per-chunk monster model.
+ */
+function chunkCopy(dest, src, y0, x0, rotate) {
+    const h = src.c.height;
+    const w = src.c.width;
+    /* Terrain, sqinfo, player. */
+    for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+            const srcGrid = loc(x, y);
+            const destGrid = symmetryTransform(srcGrid, y0, x0, h, w, rotate, false);
+            dest.c.setFeat(destGrid, src.c.feat(srcGrid));
+            dest.c.info(destGrid).copy(src.c.info(srcGrid));
+        }
+    }
+    if (src.playerSpot) {
+        dest.playerSpot = symmetryTransform(src.playerSpot, y0, x0, h, w, rotate, false);
+    }
+    /* Dungeon objects. */
+    for (const po of src.objects) {
+        const destGrid = symmetryTransform(po.grid, y0, x0, h, w, rotate, false);
+        po.obj.grid = destGrid;
+        dest.addObject(destGrid, po.obj);
+    }
+    /* Traps. */
+    for (const idx of src.trapGrids) {
+        const srcGrid = loc(idx % w, Math.trunc(idx / w));
+        const destGrid = symmetryTransform(srcGrid, y0, x0, h, w, rotate, false);
+        dest.markTrap(destGrid);
+    }
+    /* Trap descriptors (kind + power) rolled at generation time (gap 9.2). */
+    for (const t of src.traps) {
+        const destGrid = symmetryTransform(t.grid, y0, x0, h, w, rotate, false);
+        dest.traps.push({ grid: destGrid, tidx: t.tidx, power: t.power });
+    }
+    /* Monsters. */
+    for (const pm of src.monsters) {
+        const destGrid = symmetryTransform(pm.grid, y0, x0, h, w, rotate, false);
+        dest.attachMonster(destGrid, pm.mon, dest.nextMonIndex());
+    }
+}
+/* ------------------------------------------------------------------ *
+ * Cave builders.
+ * ------------------------------------------------------------------ */
+function sizePercent(rng, depth, quest) {
+    const i = rng.randint1(10) + Math.trunc(depth / 24);
+    if (quest)
+        return 100;
+    if (i < 2)
+        return 75;
+    if (i < 3)
+        return 80;
+    if (i < 4)
+        return 85;
+    if (i < 5)
+        return 90;
+    if (i < 6)
+        return 95;
+    return 100;
+}
+function alloc2dBool(rows, cols) {
+    const m = [];
+    for (let i = 0; i < rows; i++)
+        m.push(new Array(cols).fill(false));
+    return m;
+}
+/**
+ * build_staircase_rooms (gen-cave.c:908-936): for a persistent level, place a
+ * 1x1 staircase room at each seeded stair connector (dun.join) so up/down
+ * stairs line up with the already-generated adjacent levels. Locates the
+ * "staircase room" profile in the active dungeon profile (upstream asserts it
+ * exists), then for each join sets dun.currJoin and builds the room at the
+ * connector's block coords ((grid - 1) / block, via room_build's
+ * finds-own-space path - buildStaircase reads dun.currJoin for the real grid).
+ * RNG-free: the staircase builder draws no RNG. Only called under dun.persist,
+ * so a default (non-persistent) game never runs it and generation is unchanged.
+ */
+function buildStaircaseRooms(g, ctx) {
+    const dun = g.dun;
+    const profile = ctx.profile.roomProfiles.find((rp) => rp.name === "staircase room");
+    if (!profile) {
+        throw new Error("gen: build_staircase_rooms: no 'staircase room' profile");
+    }
+    for (const join of dun.join) {
+        dun.currJoin = join;
+        if (!roomBuild(g, Math.trunc((join.grid.y - 1) / dun.blockHgt), Math.trunc((join.grid.x - 1) / dun.blockWid), profile, true, ctx.rooms)) {
+            throw new Error(`gen: build_staircase_rooms: failed to place staircase room at ` +
+                `row=${join.grid.y} col=${join.grid.x}`);
+        }
+        dun.nstairRoom++;
+    }
+}
+/** classic_gen. */
+export const classicGen = (ctx) => {
+    const { rng, reg, constants, dun, profile, depth } = ctx;
+    const numRooms = Math.trunc((profile.dunRooms * sizePercent(rng, depth, dun.quest)) / 100);
+    dun.blockHgt = profile.blockSize;
+    dun.blockWid = profile.blockSize;
+    const c = new Chunk(reg, constants.dungeonHgt, constants.dungeonWid);
+    c.depth = depth;
+    const g = makeGen(ctx, c);
+    fillRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.GRANITE, SQUARE.NONE);
+    dun.rowBlocks = Math.trunc(c.height / dun.blockHgt);
+    dun.colBlocks = Math.trunc(c.width / dun.blockWid);
+    dun.roomMap = alloc2dBool(dun.rowBlocks, dun.colBlocks);
+    const blocksTried = alloc2dBool(dun.rowBlocks, dun.colBlocks);
+    dun.pitNum = 0;
+    dun.centN = 0;
+    dun.resetEntranceData(c);
+    /* Persistent levels (gen-cave.c:1183-1186): place the staircase rooms that
+     * align with the adjacent levels before the ordinary rooms. Off by default. */
+    if (dun.persist)
+        buildStaircaseRooms(g, ctx);
+    let built = 0;
+    while (built < numRooms) {
+        let j = 0;
+        let tby = 0;
+        let tbx = 0;
+        for (let by = 0; by < dun.rowBlocks; by++) {
+            for (let bx = 0; bx < dun.colBlocks; bx++) {
+                if (blocksTried[by][bx])
+                    continue;
+                j++;
+                if (rng.oneIn(j)) {
+                    tby = by;
+                    tbx = bx;
+                }
+            }
+        }
+        if (j === 0)
+            break;
+        blocksTried[tby][tbx] = true;
+        const key = rng.randint0(100);
+        let rarity = 0;
+        let i = 0;
+        while (i === rarity && i < profile.maxRarity) {
+            if (rng.randint0(profile.dunUnusual) < 50 + Math.trunc(c.depth / 2))
+                rarity++;
+            i++;
+        }
+        for (const rp of profile.roomProfiles) {
+            if (rp.rarity > rarity)
+                continue;
+            if (rp.cutoff <= key)
+                continue;
+            if (roomBuild(g, tby, tbx, rp, false, ctx.rooms)) {
+                built++;
+                break;
+            }
+        }
+    }
+    if (built < 2)
+        return { gen: null, error: "less than two rooms created" };
+    drawRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.PERM, SQUARE.NONE, true);
+    doTraditionalTunneling(g);
+    ensureConnectedness(g, true);
+    for (let i = 0; i < profile.str.mag; i++)
+        buildStreamer(g, FEAT.MAGMA, profile.str.mc);
+    for (let i = 0; i < profile.str.qua; i++)
+        buildStreamer(g, FEAT.QUARTZ, profile.str.qc);
+    handleLevelStairs(g, dun.quest, rng.randRange(3, 4), rng.randRange(1, 2));
+    const k = Math.max(Math.min(Math.trunc(c.depth / 3), 10), 2);
+    allocObjects(g, SET_CORR, TYP_RUBBLE, rng.randint1(k), c.depth, 0);
+    allocObjects(g, SET_CORR, TYP_TRAP, Math.trunc(rng.randint1(k) / 5), c.depth, 0);
+    const pspot = newPlayerSpot(g, ctx.createStair ?? null);
+    if (!pspot)
+        return { gen: null, error: "could not place player" };
+    g.playerSpot = pspot;
+    let mcount = constants.levelMonsterMin + rng.randint1(8) + k;
+    for (; mcount > 0; mcount--)
+        pickAndPlaceDistantMonster(g, pspot, 0, true, c.depth);
+    allocObjects(g, SET_ROOM, TYP_OBJECT, rng.randNormal(constants.roomItemAv, 3), c.depth, ORIGIN.FLOOR);
+    allocObjects(g, SET_BOTH, TYP_OBJECT, rng.randNormal(constants.bothItemAv, 3), c.depth, ORIGIN.FLOOR);
+    allocObjects(g, SET_BOTH, TYP_GOLD, rng.randNormal(constants.bothGoldAv, 3), c.depth, ORIGIN.FLOOR);
+    return { gen: g, error: null };
+};
+/** modified_chunk: build the room+tunnel skeleton for a modified level. */
+function modifiedChunk(ctx, height, width) {
+    const { rng, reg, constants, dun, profile, depth } = ctx;
+    const c = new Chunk(reg, height, width);
+    c.depth = depth;
+    const g = makeGen(ctx, c);
+    const numFloors = Math.trunc((c.height * c.width) / 7);
+    fillRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.GRANITE, SQUARE.NONE);
+    drawRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.PERM, SQUARE.NONE, true);
+    dun.rowBlocks = Math.trunc(c.height / dun.blockHgt);
+    dun.colBlocks = Math.trunc(c.width / dun.blockWid);
+    dun.roomMap = alloc2dBool(dun.rowBlocks, dun.colBlocks);
+    dun.pitNum = 0;
+    dun.centN = 0;
+    dun.resetEntranceData(c);
+    /* Persistent levels (gen-cave.c:2770-2773 / 3016-3019): both modified_chunk
+     * and moria_chunk place their staircase rooms here before the ordinary rooms.
+     * Off by default. */
+    if (dun.persist)
+        buildStaircaseRooms(g, ctx);
+    let nAttempt = 0;
+    for (;;) {
+        if ((c.featCount[FEAT.FLOOR] ?? 0) >= numFloors && dun.centN >= 2)
+            break;
+        if (nAttempt > 500)
+            return null;
+        nAttempt++;
+        const key = rng.randint0(100);
+        let rarity = 0;
+        let i = 0;
+        while (i === rarity && i < profile.maxRarity) {
+            if (rng.randint0(profile.dunUnusual) < 50 + Math.trunc(c.depth / 2))
+                rarity++;
+            i++;
+        }
+        for (const rp of profile.roomProfiles) {
+            if (rp.rarity > rarity)
+                continue;
+            if (rp.cutoff <= key)
+                continue;
+            if (roomBuild(g, 0, 0, rp, true, ctx.rooms))
+                break;
+        }
+    }
+    doTraditionalTunneling(g);
+    ensureConnectedness(g, true);
+    drawRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.GRANITE, SQUARE.NONE, true);
+    return g;
+}
+/**
+ * modified_gen / moria_gen shared body (gen-cave.c L2872 / L3110). moria_gen is
+ * a modified-style level whose only differences are the profile (its own room
+ * list, incl. "moria room") and a mon_restrict("Moria dwellers") wrap around
+ * the monster placement loop. moria_chunk is byte-for-byte identical to
+ * modified_chunk, so both use modifiedChunk with the caller's profile.
+ *
+ * `restrict` is the pit-profile name to restrict monsters to (null for
+ * modified). mon_restrict for a named pit draws no RNG, so the null path is
+ * RNG-identical to the original modified_gen.
+ */
+function modifiedStyleGen(ctx, restrict) {
+    const { rng, constants, dun, depth } = ctx;
+    const sp = sizePercent(rng, depth, dun.quest);
+    let ySize = Math.trunc((constants.dungeonHgt * (sp - 5 + rng.randint0(10))) / 100);
+    let xSize = Math.trunc((constants.dungeonWid * (sp - 5 + rng.randint0(10))) / 100);
+    ySize = Math.min(Math.max(ySize, ctx.minHeight), constants.dungeonHgt);
+    xSize = Math.min(Math.max(xSize, ctx.minWidth), constants.dungeonWid);
+    dun.blockHgt = ctx.profile.blockSize;
+    dun.blockWid = ctx.profile.blockSize;
+    const g = modifiedChunk(ctx, Math.min(constants.dungeonHgt, ySize), Math.min(constants.dungeonWid, xSize));
+    if (!g)
+        return { gen: null, error: "modified chunk could not be created" };
+    const c = g.c;
+    drawRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.PERM, SQUARE.NONE, true);
+    for (let i = 0; i < ctx.profile.str.mag; i++)
+        buildStreamer(g, FEAT.MAGMA, ctx.profile.str.mc);
+    for (let i = 0; i < ctx.profile.str.qua; i++)
+        buildStreamer(g, FEAT.QUARTZ, ctx.profile.str.qc);
+    handleLevelStairs(g, dun.quest, rng.randRange(3, 4), rng.randRange(1, 2));
+    const k = Math.max(Math.min(Math.trunc(c.depth / 3), 10), 2);
+    allocObjects(g, SET_CORR, TYP_RUBBLE, rng.randint1(k), c.depth, 0);
+    allocObjects(g, SET_CORR, TYP_TRAP, Math.trunc(rng.randint1(k) / 5), c.depth, 0);
+    const pspot = newPlayerSpot(g, ctx.createStair ?? null);
+    if (!pspot)
+        return { gen: null, error: "could not place player" };
+    g.playerSpot = pspot;
+    let mcount = constants.levelMonsterMin + rng.randint1(8) + k;
+    /* moria: restrict to cave dwellers. "Moria dwellers" is a pit name, so the
+     * restrict draws no RNG (races[] is unused for the named-pit path). */
+    const pits = ctx.monDeps?.pits;
+    if (restrict !== null && ctx.monDeps && pits) {
+        monRestrict(rng, ctx.monDeps.table, [], pits, restrict, c.depth, c.depth, true);
+    }
+    for (; mcount > 0; mcount--)
+        pickAndPlaceDistantMonster(g, pspot, 0, true, c.depth);
+    if (restrict !== null && ctx.monDeps && pits) {
+        monRestrict(rng, ctx.monDeps.table, [], pits, null, c.depth, c.depth, false);
+    }
+    allocObjects(g, SET_ROOM, TYP_OBJECT, rng.randNormal(constants.roomItemAv, 3), c.depth, ORIGIN.FLOOR);
+    allocObjects(g, SET_BOTH, TYP_OBJECT, rng.randNormal(constants.bothItemAv, 3), c.depth, ORIGIN.FLOOR);
+    allocObjects(g, SET_BOTH, TYP_GOLD, rng.randNormal(constants.bothGoldAv, 3), c.depth, ORIGIN.FLOOR);
+    return { gen: g, error: null };
+}
+/** modified_gen. */
+export const modifiedGen = (ctx) => modifiedStyleGen(ctx, null);
+/** moria_gen (gen-cave.c L3110): an Oangband-style moria level. */
+export const moriaGen = (ctx) => modifiedStyleGen(ctx, "Moria dwellers");
+/* ------------------------------------------------------------------ *
+ * Labyrinth generator (gen-cave.c labyrinth_chunk / labyrinth_gen).
+ * ------------------------------------------------------------------ */
+/**
+ * lab_get_adjoin: given an adjoining wall index i in a width-w labyrinth,
+ * return the two cell indices [a, b] it separates.
+ */
+function labGetAdjoin(i, w) {
+    const grid = iToGrid(i, w);
+    if (grid.x % 2 === 0) {
+        return [gridToI(nextGrid(grid, DIR_N), w), gridToI(nextGrid(grid, DIR_S), w)];
+    }
+    return [gridToI(nextGrid(grid, DIR_W), w), gridToI(nextGrid(grid, DIR_E), w)];
+}
+/**
+ * lab_is_tunnel: true if grid is a straight (non-intersection) passage - the
+ * squares on one axis are open and on the other are walls. Doors count as open.
+ */
+function labIsTunnel(c, grid) {
+    const open = (g) => c.isPassable(g) || c.isClosedDoor(g);
+    const west = open(nextGrid(grid, DIR_W));
+    const east = open(nextGrid(grid, DIR_E));
+    const north = open(nextGrid(grid, DIR_N));
+    const south = open(nextGrid(grid, DIR_S));
+    return north === south && west === east && north !== west;
+}
+/**
+ * labyrinth_chunk: build an h x w labyrinth (in a chunk sized h+2 x w+2 with a
+ * perma-rock border) using a randomized Kruskal's algorithm. NEW helpers:
+ * labGetAdjoin/labIsTunnel (the maze index math and tunnel test).
+ */
+function labyrinthChunk(ctx, depth, h, w, lit, soft) {
+    const { rng, reg } = ctx;
+    const c = new Chunk(reg, h + 2, w + 2);
+    c.depth = depth;
+    const g = makeGen(ctx, c);
+    /* Number of squares in the labyrinth. */
+    const n = h * w;
+    /* sets[i] tracks connectedness; walls[i] is the shuffle list. */
+    const sets = new Array(n);
+    const walls = new Array(n);
+    /* Bound with perma-rock; fill the interior with rock. */
+    drawRectangle(c, 0, 0, h + 1, w + 1, FEAT.PERM, SQUARE.NONE, true);
+    if (soft)
+        fillRectangle(c, 1, 1, h, w, FEAT.GRANITE, SQUARE.WALL_SOLID);
+    else
+        fillRectangle(c, 1, 1, h, w, FEAT.PERM, SQUARE.NONE);
+    for (let i = 0; i < n; i++) {
+        walls[i] = i;
+        sets[i] = -1;
+    }
+    /* Cut out a grid of 1x1 "cells". next_grid(grid, DIR_SE) translates
+     * labyrinth-space (0-based) into chunk-space (offset by the border). */
+    for (let gy = 0; gy < h; gy += 2) {
+        for (let gx = 0; gx < w; gx += 2) {
+            const grid = loc(gx, gy);
+            const kLocal = gridToI(grid, w);
+            const diag = nextGrid(grid, DIR_SE);
+            sets[kLocal] = kLocal;
+            c.setFeat(diag, FEAT.FLOOR);
+            if (lit)
+                c.sqinfoOn(diag, SQUARE.GLOW);
+        }
+    }
+    /* Shuffle the walls, then run randomized Kruskal's algorithm. */
+    shuffle(rng, walls, n);
+    for (let i = 0; i < n; i++) {
+        const j = walls[i];
+        const grid = iToGrid(j, w);
+        if ((grid.x < 1 && grid.y < 1) || (grid.x > w - 2 && grid.y > h - 2))
+            continue;
+        if (grid.x % 2 === grid.y % 2)
+            continue;
+        const [a, b] = labGetAdjoin(j, w);
+        if (sets[a] !== sets[b]) {
+            const sa = sets[a];
+            const sb = sets[b];
+            const diag = nextGrid(grid, DIR_SE);
+            c.setFeat(diag, FEAT.FLOOR);
+            if (lit)
+                c.sqinfoOn(diag, SQUARE.GLOW);
+            for (let k = 0; k < n; k++)
+                if (sets[k] === sb)
+                    sets[k] = sa;
+        }
+    }
+    /* Generate a closed door for every 100 squares in the labyrinth. */
+    const finder = new CaveFinder(loc(1, 1), loc(c.width - 2, c.height - 2));
+    let doors = Math.trunc(n / 100);
+    while (doors > 0) {
+        const grid = finder.get(rng);
+        if (!grid)
+            break;
+        if (squareIsEmpty(g, grid) && labIsTunnel(c, grid)) {
+            placeClosedDoor(g, grid);
+            doors--;
+        }
+    }
+    /* Unlit labyrinths hold some good items; hard (non-diggable) ones some great. */
+    if (!lit)
+        allocObjects(g, SET_BOTH, TYP_GOOD, rng.randNormal(3, 2), c.depth, ORIGIN.LABYRINTH);
+    if (!soft)
+        allocObjects(g, SET_BOTH, TYP_GREAT, rng.randNormal(2, 1), c.depth, ORIGIN.LABYRINTH);
+    return g;
+}
+/** labyrinth_gen: build a labyrinth level. */
+export const labyrinthGen = (ctx) => {
+    const { rng, constants, dun, depth } = ctx;
+    /* The labyrinth area (excluding the enclosing walls) must be odd-sized. */
+    let h = 15 + rng.randint0(Math.trunc(depth / 10)) * 2;
+    let w = 51 + rng.randint0(Math.trunc(depth / 10)) * 2;
+    /* Most labyrinths are lit; many lit ones are known; most have soft walls. */
+    const lit = rng.randint0(depth) < 25 || rng.randint0(2) < 1;
+    const known = lit && rng.randint0(depth) < 25;
+    const soft = rng.randint0(depth) < 35 || rng.randint0(3) < 2;
+    /* No persistent levels of this type for now. */
+    if (dun.persist) {
+        return { gen: null, error: "no labyrinth levels in persistent dungeons" };
+    }
+    /* Enforce minimum dimensions. */
+    h = Math.max(h, ctx.minHeight);
+    w = Math.max(w, ctx.minWidth);
+    const g = labyrinthChunk(ctx, depth, h, w, lit, soft);
+    const c = g.c;
+    /* Determine the character location. */
+    const pspot = newPlayerSpot(g, ctx.createStair ?? null);
+    if (!pspot)
+        return { gen: null, error: "could not place player" };
+    g.playerSpot = pspot;
+    /* A single set of up/down stairs, if not already present. */
+    if (!caveFind(c, rng, (cc, gr) => cc.isUpstairs(gr))) {
+        allocStairs(g, FEAT.LESS, 1, 0, false, dun.oneOffAbove, dun.quest);
+    }
+    if (!caveFind(c, rng, (cc, gr) => cc.isDownstairs(gr))) {
+        allocStairs(g, FEAT.MORE, 1, 0, false, dun.oneOffBelow, dun.quest);
+    }
+    /* Rubble, traps and monsters, scaled by labyrinth size. */
+    let k = Math.max(Math.min(Math.trunc(c.depth / 3), 10), 2);
+    k = Math.trunc((3 * k * (h * w)) / (constants.dungeonHgt * constants.dungeonWid));
+    allocObjects(g, SET_BOTH, TYP_RUBBLE, rng.randint1(k), c.depth, 0);
+    allocObjects(g, SET_CORR, TYP_TRAP, rng.randint1(k), c.depth, 0);
+    let mcount = constants.levelMonsterMin + rng.randint1(8) + k;
+    for (; mcount > 0; mcount--)
+        pickAndPlaceDistantMonster(g, pspot, 0, true, c.depth);
+    allocObjects(g, SET_BOTH, TYP_OBJECT, rng.randNormal(k * 6, 2), c.depth, ORIGIN.LABYRINTH);
+    allocObjects(g, SET_BOTH, TYP_GOLD, rng.randNormal(k * 3, 2), c.depth, ORIGIN.LABYRINTH);
+    allocObjects(g, SET_BOTH, TYP_GOOD, rng.randint1(2), c.depth, ORIGIN.LABYRINTH);
+    /* "Notify if we want the player to see the maze layout" (gen-cave.c:1593-1596):
+     * a known labyrinth sets p->upkeep->light_level, which cave_generate consumes
+     * as wiz_light(chunk, p, false) (generate.c:1255-1258). No RNG, no layout
+     * effect - it perma-lights the level. */
+    if (known)
+        g.lightLevel = true;
+    return { gen: g, error: null };
+};
+/* ------------------------------------------------------------------ *
+ * Cavern generator (gen-cave.c init_cavern / mutate_cavern /
+ * clear_small_regions / cavern_chunk / cavern_gen). Cellular-automaton cave.
+ * ------------------------------------------------------------------ */
+const MAX_CAVERN_TRIES = 10;
+/**
+ * init_cavern: fill the chunk with rock, then open `density` percent of the
+ * interior to floor at random. The `join` connector list (empty for
+ * non-persistent levels) builds in stairs surrounded by protected floor/rock;
+ * it is ported faithfully but dormant until persistent levels wire dun.join.
+ */
+function initCavern(g, density, join) {
+    const c = g.c;
+    const rng = g.rng;
+    const h = c.height;
+    const w = c.width;
+    const size = h * w;
+    let count = Math.trunc((size * density) / 100);
+    /* Fill the entire chunk with rock. */
+    fillRectangle(c, 0, 0, h - 1, w - 1, FEAT.GRANITE, SQUARE.WALL_SOLID);
+    /* Add in the desired stairs (dormant for non-persistent levels). */
+    for (const j of join) {
+        if (j.grid.y > 0 &&
+            j.grid.y < h - 1 &&
+            j.grid.x > 0 &&
+            j.grid.x < w - 1 &&
+            !c.isStairs(j.grid)) {
+            const bcrit = rng.randint0(h) + (j.grid.y > Math.trunc(h / 2) ? -10 : 10);
+            const rcrit = rng.randint0(w) + (j.grid.x > Math.trunc(w / 2) ? -10 : 10);
+            const offy = bcrit > j.grid.y ? 1 : -1;
+            const offx = rcrit > j.grid.x ? 1 : -1;
+            if (!c.isFloor(j.grid))
+                count--;
+            c.setFeat(j.grid, j.feat);
+            let adj = loc(j.grid.x + offx, j.grid.y + offy);
+            if (!c.isStairs(adj) && !c.isFloor(adj)) {
+                count--;
+                c.setFeat(adj, FEAT.FLOOR);
+            }
+            adj = loc(j.grid.x, j.grid.y + offy);
+            if (!c.isStairs(adj) && !c.isFloor(adj)) {
+                count--;
+                c.setFeat(adj, FEAT.FLOOR);
+            }
+            adj = loc(j.grid.x + offx, j.grid.y);
+            if (!c.isStairs(adj) && !c.isFloor(adj)) {
+                count--;
+                c.setFeat(adj, FEAT.FLOOR);
+            }
+            adj = loc(j.grid.x - offx, j.grid.y - offy);
+            if (c.isGranite(adj))
+                c.setFeat(adj, FEAT.PERM);
+            adj = loc(j.grid.x, j.grid.y - offy);
+            if (c.isGranite(adj))
+                c.setFeat(adj, FEAT.PERM);
+            adj = loc(j.grid.x - offx, j.grid.y);
+            if (c.isGranite(adj))
+                c.setFeat(adj, FEAT.PERM);
+        }
+    }
+    while (count > 0) {
+        const grid = loc(rng.randint1(w - 2), rng.randint1(h - 2));
+        if (c.isGranite(grid)) {
+            c.setFeat(grid, FEAT.FLOOR);
+            count--;
+        }
+    }
+}
+/** mutate_cavern: one pass of the (4,5) cellular-automaton rules. No RNG. */
+function mutateCavern(g) {
+    const c = g.c;
+    const h = c.height;
+    const w = c.width;
+    const temp = new Int32Array(h * w);
+    const passable = (cc, gr) => cc.isPassable(gr);
+    for (let y = 1; y < h - 1; y++) {
+        for (let x = 1; x < w - 1; x++) {
+            const grid = loc(x, y);
+            const count = 8 - countNeighbors(c, grid, passable, false);
+            const i = gridToI(grid, w);
+            if (c.isStairs(grid) || c.isPerm(grid))
+                temp[i] = c.feat(grid);
+            else if (count > 5)
+                temp[i] = FEAT.GRANITE;
+            else if (count < 4)
+                temp[i] = FEAT.FLOOR;
+            else
+                temp[i] = c.feat(grid);
+        }
+    }
+    for (let y = 1; y < h - 1; y++) {
+        for (let x = 1; x < w - 1; x++) {
+            const grid = loc(x, y);
+            const feat = temp[gridToI(grid, w)];
+            if (feat === FEAT.GRANITE)
+                setMarkedGranite(c, grid, SQUARE.WALL_SOLID);
+            else
+                c.setFeat(grid, feat);
+        }
+    }
+}
+/**
+ * clear_small_regions: delete all open regions smaller than 9 squares (turning
+ * them back to granite). No stair-preservation here: join is empty for
+ * non-persistent levels, so no region carries a staircase to protect.
+ */
+function clearSmallRegions(g, colors, counts) {
+    const c = g.c;
+    const size = c.height * c.width;
+    const deleted = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        if (counts[i] < 9) {
+            deleted[i] = 1;
+            counts[i] = 0;
+        }
+    }
+    for (let y = 1; y < c.height - 1; y++) {
+        for (let x = 1; x < c.width - 1; x++) {
+            const grid = loc(x, y);
+            const i = gridToI(grid, c.width);
+            if (!deleted[colors[i]])
+                continue;
+            colors[i] = 0;
+            setMarkedGranite(c, grid, SQUARE.WALL_SOLID);
+        }
+    }
+}
+/**
+ * cavern_chunk: build a cellular-automaton cavern, regenerating (up to
+ * MAX_CAVERN_TRIES times) until enough floor is open, then colour the regions,
+ * delete the small ones and join the rest into one connected cave. Returns null
+ * if no large-enough cavern could be made. Reuses the file's buildColors /
+ * joinRegion / countColors / firstColor region machinery.
+ */
+function cavernChunk(ctx, depth, h, w, join) {
+    const { rng, reg } = ctx;
+    const size = h * w;
+    const limit = Math.trunc(size / 13);
+    const density = rng.randRange(25, 40);
+    const times = rng.randRange(3, 6);
+    const c = new Chunk(reg, h, w);
+    c.depth = depth;
+    const g = makeGen(ctx, c);
+    let tries = 0;
+    for (; tries < MAX_CAVERN_TRIES; tries++) {
+        initCavern(g, density, join);
+        for (let i = 0; i < times; i++)
+            mutateCavern(g);
+        if ((c.featCount[FEAT.FLOOR] ?? 0) >= limit)
+            break;
+    }
+    if (tries === MAX_CAVERN_TRIES)
+        return null;
+    const colors = new Int32Array(size);
+    const counts = new Int32Array(size);
+    buildColors(g, colors, counts, false);
+    clearSmallRegions(g, colors, counts);
+    let num = countColors(counts);
+    while (num > 1) {
+        joinRegion(g, colors, counts, firstColor(counts), -1, true);
+        num--;
+    }
+    /* Convert the permanent rock walls near stairs back to granite (dormant). */
+    for (const j of join) {
+        for (let i = 0; i < 8; i++) {
+            const adj = locSum(j.grid, DDGRID_DDD[i]);
+            if (c.inBounds(adj) && c.isPerm(adj))
+                setMarkedGranite(c, adj, SQUARE.WALL_SOLID);
+        }
+    }
+    return g;
+}
+/** cavern_gen: build a cavern level. */
+export const cavernGen = (ctx) => {
+    const { rng, constants, dun, depth } = ctx;
+    let h = rng.randRange(Math.trunc(constants.dungeonHgt / 2), Math.trunc((constants.dungeonHgt * 3) / 4));
+    let w = rng.randRange(Math.trunc(constants.dungeonWid / 2), Math.trunc((constants.dungeonWid * 3) / 4));
+    /* Enforce minimum dimensions. */
+    h = Math.max(h, ctx.minHeight);
+    w = Math.max(w, ctx.minWidth);
+    const g = cavernChunk(ctx, depth, h, w, dun.join);
+    if (!g)
+        return { gen: null, error: "cavern chunk could not be created" };
+    const c = g.c;
+    /* Surround the level with perma-rock. */
+    drawRectangle(c, 0, 0, h - 1, w - 1, FEAT.PERM, SQUARE.NONE, true);
+    /* Place 1-3 down stairs and 1-2 up stairs near some walls. */
+    handleLevelStairs(g, dun.quest, rng.randRange(1, 3), rng.randRange(1, 2));
+    /* Rubble, traps and monsters, scaled (with a floor of 6) by cavern size. */
+    let k = Math.max(Math.min(Math.trunc(c.depth / 3), 10), 2);
+    k = Math.max(Math.trunc((4 * k * (h * w)) / (constants.dungeonHgt * constants.dungeonWid)), 6);
+    allocObjects(g, SET_BOTH, TYP_RUBBLE, rng.randint1(k), c.depth, 0);
+    allocObjects(g, SET_CORR, TYP_TRAP, rng.randint1(k), c.depth, 0);
+    /* Determine the character location. */
+    const pspot = newPlayerSpot(g, ctx.createStair ?? null);
+    if (!pspot)
+        return { gen: null, error: "could not place player" };
+    g.playerSpot = pspot;
+    let mcount = rng.randint1(8) + k;
+    for (; mcount > 0; mcount--)
+        pickAndPlaceDistantMonster(g, pspot, 0, true, c.depth);
+    allocObjects(g, SET_BOTH, TYP_OBJECT, rng.randNormal(k, 2), c.depth + 5, ORIGIN.CAVERN);
+    allocObjects(g, SET_BOTH, TYP_GOLD, rng.randNormal(Math.trunc(k / 2), 2), c.depth, ORIGIN.CAVERN);
+    allocObjects(g, SET_BOTH, TYP_GOOD, rng.randint0(Math.trunc(k / 4)), c.depth, ORIGIN.CAVERN);
+    return { gen: g, error: null };
+};
+/* ------------------------------------------------------------------ *
+ * Lair generator (gen-cave.c lair_gen L3534): a modified-style half joined to
+ * a themed-monster cavern half.
+ * ------------------------------------------------------------------ */
+export const lairGen = (ctx) => {
+    const { rng, reg, constants, dun, depth } = ctx;
+    /* Scale the level (identical ladder to modified/moria). */
+    const sp = sizePercent(rng, depth, dun.quest);
+    let ySize = Math.trunc((constants.dungeonHgt * (sp - 5 + rng.randint0(10))) / 100);
+    let xSize = Math.trunc((constants.dungeonWid * (sp - 5 + rng.randint0(10))) / 100);
+    ySize = Math.min(Math.max(ySize, ctx.minHeight), constants.dungeonHgt);
+    xSize = Math.min(Math.max(xSize, ctx.minWidth), constants.dungeonWid);
+    dun.blockHgt = ctx.profile.blockSize;
+    dun.blockWid = ctx.profile.blockSize;
+    /* Non-persistent: split the level down the middle. */
+    const leftWidth = Math.trunc(xSize / 2);
+    let normalWidth;
+    let normalOffset;
+    let lairWidth;
+    let lairOffset;
+    if (rng.oneIn(2)) {
+        /* Normal part on the left. */
+        normalWidth = leftWidth;
+        normalOffset = 0;
+        lairWidth = xSize - leftWidth;
+        lairOffset = leftWidth;
+    }
+    else {
+        /* Lair part on the left. */
+        normalWidth = xSize - leftWidth;
+        normalOffset = leftWidth;
+        lairWidth = leftWidth;
+        lairOffset = 0;
+    }
+    const normal = modifiedChunk(ctx, ySize, normalWidth);
+    if (!normal)
+        return { gen: null, error: "modified chunk could not be created" };
+    const lair = cavernChunk(ctx, depth, ySize, lairWidth, dun.join);
+    if (!lair)
+        return { gen: null, error: "cavern chunk could not be created" };
+    /* General amount of rubble, traps and monsters (halved for lairs). */
+    const k = Math.trunc(Math.max(Math.min(Math.trunc(depth / 3), 10), 2) / 2);
+    /* Put the character in the normal half. */
+    const pspot = newPlayerSpot(normal, ctx.createStair ?? null);
+    if (!pspot)
+        return { gen: null, error: "could not place player" };
+    normal.playerSpot = pspot;
+    /* A smallish number of monsters for the normal half. */
+    let nmon = rng.randint1(4) + k;
+    for (; nmon > 0; nmon--) {
+        pickAndPlaceDistantMonster(normal, pspot, 0, true, normal.c.depth);
+    }
+    /* Magma / quartz streamers in the normal half. */
+    for (let i = 0; i < ctx.profile.str.mag; i++)
+        buildStreamer(normal, FEAT.MAGMA, ctx.profile.str.mc);
+    for (let i = 0; i < ctx.profile.str.qua; i++)
+        buildStreamer(normal, FEAT.QUARTZ, ctx.profile.str.qc);
+    /* A larger number of themed monsters for the lair. */
+    const lairMon = constants.levelMonsterMin + rng.randint1(20) + k;
+    const pits = ctx.monDeps?.pits;
+    if (ctx.monDeps && pits) {
+        const table = ctx.monDeps.table;
+        const lairDepth = lair.c.depth;
+        let pit = pits[0];
+        for (;;) {
+            pit = setPitType(rng, pits, lairDepth, 0);
+            if (monRestrict(rng, table, [], pits, pit.name, lairDepth, lairDepth, true).ok)
+                break;
+        }
+        spreadMonsters(lair, [], pits, pit.name, lairDepth, lairMon, Math.trunc(lair.c.height / 2), Math.trunc(lair.c.width / 2), Math.trunc(lair.c.height / 2), Math.trunc(lair.c.width / 2), 
+        /* spread_monsters (gen-cave.c L3671-3673): lair monsters carry
+         * ORIGIN_CAVERN, which monster_death does NOT count for lore treasure. */
+        ORIGIN.CAVERN);
+        monRestrict(rng, table, [], pits, null, lairDepth, lairDepth, false);
+    }
+    /* Assemble the level. */
+    const c = new Chunk(reg, ySize, xSize);
+    c.depth = depth;
+    const g = makeGen(ctx, c);
+    chunkCopy(g, normal, 0, normalOffset, 0);
+    chunkCopy(g, lair, 0, lairOffset, 0);
+    /* Perma-rock border, then connect the two halves. */
+    drawRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.PERM, SQUARE.NONE, true);
+    ensureConnectedness(g, true);
+    handleLevelStairs(g, dun.quest, rng.randRange(3, 4), rng.randRange(1, 2));
+    allocObjects(g, SET_CORR, TYP_RUBBLE, rng.randint1(k), c.depth, 0);
+    allocObjects(g, SET_CORR, TYP_TRAP, Math.trunc(rng.randint1(k) / 5), c.depth, 0);
+    allocObjects(g, SET_ROOM, TYP_OBJECT, rng.randNormal(constants.roomItemAv, 3), c.depth, ORIGIN.FLOOR);
+    allocObjects(g, SET_BOTH, TYP_OBJECT, rng.randNormal(constants.bothItemAv, 3), c.depth, ORIGIN.FLOOR);
+    allocObjects(g, SET_BOTH, TYP_GOLD, rng.randNormal(constants.bothGoldAv, 3), c.depth, ORIGIN.FLOOR);
+    return { gen: g, error: null };
+};
+/* ------------------------------------------------------------------ *
+ * Gauntlet generator (gen-cave.c gauntlet_gen L3734): two caverns with an
+ * unmappable labyrinth "gauntlet" between them.
+ * ------------------------------------------------------------------ */
+export const gauntletGen = (ctx) => {
+    const { rng, reg, constants, dun, depth } = ctx;
+    const gauntletHgt = 2 * rng.randint1(5) + 3;
+    const gauntletWid = 2 * rng.randint1(10) + 19;
+    const ySize = constants.dungeonHgt - rng.randint0(25 - gauntletHgt);
+    /* labyrinth_chunk() yields something two grids wider than requested, hence
+     * the extra "- 2" below (see gen-cave.c L3746). */
+    const xSize = Math.trunc((constants.dungeonWid - gauntletWid - 2) / 2) - rng.randint0(45 - gauntletWid);
+    /* No persistent levels of this type for now. */
+    if (dun.persist) {
+        return { gen: null, error: "no gauntlet levels in persistent dungeons" };
+    }
+    const gauntlet = labyrinthChunk(ctx, depth, gauntletHgt, gauntletWid, false, false);
+    const left = cavernChunk(ctx, depth, ySize, xSize, []);
+    if (!left)
+        return { gen: null, error: "left cavern chunk could not be generated" };
+    const right = cavernChunk(ctx, depth, ySize, xSize, []);
+    if (!right)
+        return { gen: null, error: "right cavern chunk could not be generated" };
+    /* Lines between the three pieces. */
+    const line1 = left.c.width;
+    const line2 = line1 + gauntlet.c.width;
+    /* Movement and mapping restrictions. */
+    generateMark(left.c, 0, 0, left.c.height - 1, left.c.width - 1, SQUARE.NO_TELEPORT);
+    generateMark(gauntlet.c, 0, 0, gauntlet.c.height - 1, gauntlet.c.width - 1, SQUARE.NO_MAP);
+    generateMark(gauntlet.c, 0, 0, gauntlet.c.height - 1, gauntlet.c.width - 1, SQUARE.NO_TELEPORT);
+    /* Down stairs in the right cavern, up stairs in the left. */
+    allocStairs(right, FEAT.MORE, rng.randRange(2, 3), 0, false, [], dun.quest);
+    allocStairs(left, FEAT.LESS, rng.randRange(1, 3), 0, false, [], dun.quest);
+    /* Open the left end of the gauntlet (adjacent to a non-perm wall). */
+    let tries = 0;
+    for (;;) {
+        const grid = loc(0, rng.randint1(gauntlet.c.height - 2));
+        if (tries >= 20)
+            return { gen: null, error: "could not open entrance to the labyrinth" };
+        if (!gauntlet.c.isPerm(locSum(grid, loc(1, 0)))) {
+            gauntlet.c.setFeat(grid, FEAT.GRANITE);
+            break;
+        }
+        tries++;
+    }
+    /* Open the right end. */
+    tries = 0;
+    for (;;) {
+        const grid = loc(gauntlet.c.width - 1, rng.randint1(gauntlet.c.height - 2));
+        if (tries >= 20)
+            return { gen: null, error: "could not open entrance to the labyrinth" };
+        if (!gauntlet.c.isPerm(locSum(grid, loc(-1, 0)))) {
+            gauntlet.c.setFeat(grid, FEAT.GRANITE);
+            break;
+        }
+        tries++;
+    }
+    const k = Math.trunc(Math.max(Math.min(Math.trunc(depth / 3), 10), 2) / 2);
+    /* Put the character in the arrival cavern (gen-cave.c:3857): the right cavern
+     * (down stairs) when arriving via create_down_stair (an ascent), else the
+     * left (up stairs). new_player_spot then lays the matching arrival stair. */
+    const createDownStair = ctx.createStair === "down";
+    const arrival = createDownStair ? right : left;
+    const pspot = newPlayerSpot(arrival, ctx.createStair ?? null);
+    if (!pspot)
+        return { gen: null, error: "could not place player" };
+    arrival.playerSpot = pspot;
+    /* Player location relative to each cavern (matching the chunk_copy offsets). */
+    let pLocInR;
+    let pLocInL;
+    if (arrival === right) {
+        pLocInR = pspot;
+        pLocInL = loc(line2 + pspot.x, pspot.y);
+    }
+    else {
+        pLocInL = pspot;
+        pLocInR = loc(pspot.x - line2, pspot.y);
+    }
+    /* Monsters for the left cavern. */
+    let lmon = constants.levelMonsterMin + rng.randint1(4) + k;
+    for (; lmon > 0; lmon--)
+        pickAndPlaceDistantMonster(left, pLocInL, 0, true, left.c.depth);
+    /* Monsters for the right cavern. */
+    let rmon = constants.levelMonsterMin + rng.randint1(4) + k;
+    for (; rmon > 0; rmon--)
+        pickAndPlaceDistantMonster(right, pLocInR, 0, true, right.c.depth);
+    /* A larger number of themed monsters for the gauntlet. */
+    const gMon = constants.levelMonsterMin + rng.randint1(6) + k;
+    const pits = ctx.monDeps?.pits;
+    if (ctx.monDeps && pits) {
+        const table = ctx.monDeps.table;
+        const gDepth = gauntlet.c.depth;
+        let pit = pits[0];
+        for (;;) {
+            pit = setPitType(rng, pits, gDepth, 0);
+            if (monRestrict(rng, table, [], pits, pit.name, gDepth, gDepth, true).ok)
+                break;
+        }
+        spreadMonsters(gauntlet, [], pits, pit.name, gDepth, gMon, Math.trunc(gauntlet.c.height / 2), Math.trunc(gauntlet.c.width / 2), Math.trunc(gauntlet.c.height / 2), Math.trunc(gauntlet.c.width / 2), 
+        /* spread_monsters (gen-cave.c L3918): gauntlet monsters carry
+         * ORIGIN_CAVERN (not counted by monster_death for lore treasure). */
+        ORIGIN.CAVERN);
+        monRestrict(rng, table, [], pits, null, gDepth, gDepth, false);
+    }
+    /* Assemble the level. */
+    const c = new Chunk(reg, ySize, left.c.width + gauntlet.c.width + right.c.width);
+    c.depth = depth;
+    const g = makeGen(ctx, c);
+    fillRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.GRANITE, SQUARE.NONE);
+    /* Permanent rock between the caverns. */
+    fillRectangle(c, 0, line1, c.height - 1, line2 - 1, FEAT.PERM, SQUARE.NONE);
+    chunkCopy(g, left, 0, 0, 0);
+    chunkCopy(g, gauntlet, Math.trunc((ySize - gauntlet.c.height) / 2), line1, 0);
+    chunkCopy(g, right, 0, line2, 0);
+    drawRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.PERM, SQUARE.NONE, true);
+    ensureConnectedness(g, true);
+    allocObjects(g, SET_CORR, TYP_RUBBLE, rng.randint1(k), c.depth, 0);
+    allocObjects(g, SET_CORR, TYP_TRAP, rng.randint1(k), c.depth, 0);
+    allocObjects(g, SET_ROOM, TYP_OBJECT, rng.randNormal(constants.roomItemAv, 3), c.depth, ORIGIN.FLOOR);
+    allocObjects(g, SET_BOTH, TYP_OBJECT, rng.randNormal(constants.bothItemAv, 3), c.depth, ORIGIN.FLOOR);
+    allocObjects(g, SET_BOTH, TYP_GOLD, rng.randNormal(constants.bothGoldAv, 3), c.depth, ORIGIN.FLOOR);
+    return { gen: g, error: null };
+};
+/* ------------------------------------------------------------------ *
+ * Hard-centre generator (gen-cave.c hard_centre_gen L3291): a greater vault at
+ * the centre, surrounded by four caverns (upper, lower, left, right) all joined
+ * together by connect_caverns and then to the vault by ensure_connectedness.
+ * ------------------------------------------------------------------ */
+export const hardCentreGen = (ctx) => {
+    const { rng, reg, constants, dun, depth } = ctx;
+    /* A factory that mints a Gen bound to a fresh sub-chunk (Gen/Chunk
+     * construction stays here; vault_chunk lives in room.ts). */
+    const makeSubGen = (h, w, d) => {
+        const cc = new Chunk(reg, h, w);
+        cc.depth = d;
+        return makeGen(ctx, cc);
+    };
+    /* Make a greater vault for the centre (gen-cave.c L3295). */
+    const centre = vaultChunk(rng, ctx.rooms.vaults, depth, makeSubGen);
+    if (!centre) {
+        return { gen: null, error: "could not create the centre vault" };
+    }
+    /* No persistent levels of this type for now (gen-cave.c L3314). */
+    if (dun.persist) {
+        return { gen: null, error: "no hard centre levels in persistent dungeons" };
+    }
+    /*
+     * Carve out entrances to the vault.  Only use one if there aren't explicitly
+     * marked entrances since those vaults typically have empty space about them
+     * and the extra entrances aren't useful (gen-cave.c L3327).
+     */
+    const ent0 = dun.entN[0] ?? 0;
+    const k0 = 1 + (ent0 > 0 ? rng.randint1(3) : 0);
+    dun.wallN = 0;
+    for (let i = 0; i < k0; i++) {
+        let grid;
+        if (ent0 === 0) {
+            /* No explicitly marked entrances: look for a SQUARE_WALL_OUTER grid. */
+            const found = caveFind(centre.c, rng, (cc, gr) => squareIswallOuter(cc, gr));
+            if (!found) {
+                if (i === 0) {
+                    return {
+                        gen: null,
+                        error: "no SQUARE_WALL_OUTER grid for an entrance to the centre vault",
+                    };
+                }
+                break;
+            }
+            grid = found;
+        }
+        else {
+            grid = chooseRandomEntrance(centre, 0, null, 0, dun.wall.slice(0, i));
+            if (grid.x === 0 && grid.y === 0) {
+                if (i === 0) {
+                    return {
+                        gen: null,
+                        error: "random selection of entrance to the centre vault failed",
+                    };
+                }
+                break;
+            }
+        }
+        /* Store position in dun->wall, mark neighbors invalid, and floor it. */
+        pierceOuterWall(centre, grid);
+        centre.c.setFeat(grid, FEAT.FLOOR);
+    }
+    /* Measure the vault, rotate to make it wider than it is high (L3368). */
+    let rotate = 0;
+    let centreCavernYpos;
+    let centreCavernHgt;
+    let centreCavernWid;
+    if (centre.c.height > centre.c.width) {
+        rotate = 1;
+        centreCavernYpos = Math.trunc((constants.dungeonHgt - centre.c.width) / 2);
+        centreCavernHgt = centre.c.width;
+        centreCavernWid = centre.c.height;
+    }
+    else {
+        centreCavernYpos = Math.trunc((constants.dungeonHgt - centre.c.height) / 2);
+        centreCavernHgt = centre.c.height;
+        centreCavernWid = centre.c.width;
+    }
+    const upperCavernHgt = centreCavernYpos;
+    const lowerCavernHgt = constants.dungeonHgt - upperCavernHgt - centreCavernHgt;
+    const lowerCavernYpos = centreCavernYpos + centreCavernHgt;
+    /* Make the caverns (gen-cave.c L3385): upper, lower, then left, right. The
+     * upstream `join` argument is NULL for all four (non-persistent). */
+    const upperCavern = cavernChunk(ctx, depth, upperCavernHgt, centreCavernWid, []);
+    const lowerCavern = cavernChunk(ctx, depth, lowerCavernHgt, centreCavernWid, []);
+    const leftCavernWid = Math.trunc((constants.dungeonWid - centreCavernWid) / 2);
+    const rightCavernWid = constants.dungeonWid - leftCavernWid - centreCavernWid;
+    const leftCavern = cavernChunk(ctx, depth, constants.dungeonHgt, leftCavernWid, []);
+    const rightCavern = cavernChunk(ctx, depth, constants.dungeonHgt, rightCavernWid, []);
+    /* Return on failure (gen-cave.c L3398). The C-side artifact/monster cleanup
+     * is not needed here: the sub-chunks are simply discarded. */
+    if (!upperCavern || !lowerCavern || !leftCavern || !rightCavern) {
+        return { gen: null, error: "could not create one or more of the surrounding caverns" };
+    }
+    /* Make a cave to copy them into, and find a floor square in each cavern. */
+    const c = new Chunk(reg, constants.dungeonHgt, constants.dungeonWid);
+    c.depth = depth;
+    const g = makeGen(ctx, c);
+    const floor = [loc(0, 0), loc(0, 0), loc(0, 0), loc(0, 0)];
+    /* find_empty_range mirrors the C single reused `grid` local: on the (never
+     * hit in practice) failure it keeps the previous value. */
+    let grid = loc(0, 0);
+    const findEmptyRange = (tl, br) => {
+        const found = caveFindInRange(c, rng, tl, br, (_cc, gr) => squareIsEmpty(g, gr));
+        if (found)
+            grid = found;
+    };
+    /* Left. */
+    chunkCopy(g, leftCavern, 0, 0, 0);
+    findEmptyRange(loc(0, 0), loc(leftCavernWid - 1, constants.dungeonHgt - 1));
+    floor[0] = grid;
+    /* Upper. */
+    chunkCopy(g, upperCavern, 0, leftCavernWid, 0);
+    findEmptyRange(loc(leftCavernWid, 0), loc(leftCavernWid + centreCavernWid - 1, upperCavernHgt - 1));
+    floor[1] = grid;
+    /* Centre. */
+    chunkCopy(g, centre, centreCavernYpos, leftCavernWid, rotate);
+    /* Lower. */
+    chunkCopy(g, lowerCavern, lowerCavernYpos, leftCavernWid, 0);
+    findEmptyRange(loc(leftCavernWid, lowerCavernYpos), loc(leftCavernWid + centreCavernWid - 1, constants.dungeonHgt - 1));
+    floor[3] = grid;
+    /* Right. */
+    chunkCopy(g, rightCavern, 0, leftCavernWid + centreCavernWid, 0);
+    findEmptyRange(loc(leftCavernWid + centreCavernWid, 0), loc(constants.dungeonWid - 1, constants.dungeonHgt - 1));
+    floor[2] = grid;
+    /* Encase in perma-rock (gen-cave.c L3457). */
+    drawRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.PERM, SQUARE.NONE, true);
+    /* Connect up all the caverns, then to the centre entrances. */
+    connectCaverns(g, floor);
+    ensureConnectedness(g, false);
+    const cavernArea = (leftCavernWid + rightCavernWid) * constants.dungeonHgt +
+        centreCavernWid * (upperCavernHgt + lowerCavernHgt);
+    /* Place 2-3 down stairs and 1-2 up stairs near some walls (minsep 0, so the
+     * avoid-list is unused; NULL upstream). */
+    allocStairs(g, FEAT.MORE, rng.randRange(1, 3), 0, false, [], dun.quest);
+    allocStairs(g, FEAT.LESS, rng.randRange(1, 2), 0, false, [], dun.quest);
+    /* Generate some rubble, traps and monsters, scaled by total cavern size. */
+    let k = Math.max(Math.min(Math.trunc(c.depth / 3), 10), 2);
+    k = Math.trunc((k * cavernArea) / (constants.dungeonHgt * constants.dungeonWid));
+    allocObjects(g, SET_BOTH, TYP_RUBBLE, rng.randint1(k), c.depth, 0);
+    allocObjects(g, SET_CORR, TYP_TRAP, rng.randint1(k), c.depth, 0);
+    /* Determine the character location. */
+    const pspot = newPlayerSpot(g, ctx.createStair ?? null);
+    if (!pspot)
+        return { gen: null, error: "could not place player" };
+    g.playerSpot = pspot;
+    let mcount = rng.randint1(8) + k;
+    for (; mcount > 0; mcount--)
+        pickAndPlaceDistantMonster(g, pspot, 0, true, c.depth);
+    allocObjects(g, SET_BOTH, TYP_OBJECT, rng.randNormal(k, 2), c.depth + 5, ORIGIN.CAVERN);
+    allocObjects(g, SET_BOTH, TYP_GOLD, rng.randNormal(Math.trunc(k / 2), 2), c.depth, ORIGIN.CAVERN);
+    allocObjects(g, SET_BOTH, TYP_GOOD, rng.randint0(Math.trunc(k / 4)), c.depth, ORIGIN.CAVERN);
+    return { gen: g, error: null };
+};
+/**
+ * The eight town entrance features, in store order: the seven shops plus the
+ * player's Home. Their FEAT_* indices are the store_at keys the store runtime
+ * looks a store up by.
+ */
+export const TOWN_STORE_FEATS = [
+    FEAT.STORE_GENERAL,
+    FEAT.STORE_ARMOR,
+    FEAT.STORE_WEAPON,
+    FEAT.STORE_BOOK,
+    FEAT.STORE_ALCHEMY,
+    FEAT.STORE_MAGIC,
+    FEAT.STORE_BLACK,
+    FEAT.HOME,
+];
+/* ------------------------------------------------------------------ *
+ * Faithful town generation (gen-cave.c town_gen_layout / town_gen).
+ *
+ * Every RNG draw is reproduced in the exact upstream order and count. The
+ * two subtleties that would otherwise diverge the seeded stream:
+ *  1. Angband's MIN/MAX (h-basic.h) are macros - (a)>(b)?(b):(a) etc - that
+ *     RE-EVALUATE the selected argument. When a randint0 lives inside a MIN/MAX
+ *     argument it is drawn once for the comparison and AGAIN when that branch
+ *     is chosen. macroMin/macroMax below model this with a thunk for the
+ *     side-effecting argument.
+ *  2. build_ruin's `!randint0(3)` is the first operand of an && so it is drawn
+ *     for every non-building grid before the floor/perimeter tests.
+ * ------------------------------------------------------------------ */
+/** MAX(a, b) = (a < b) ? b : a with the C-macro re-evaluation of b. */
+function macroMax(a, bThunk) {
+    const b = bThunk();
+    return a < b ? bThunk() : a;
+}
+/** MIN(a, b) = (a > b) ? b : a with the C-macro re-evaluation of b. */
+function macroMin(a, bThunk) {
+    const b = bThunk();
+    return a > b ? bThunk() : a;
+}
+/** get_lot_bounds (gen-cave.c L2243): the grid bounds of a town lot. */
+function getLotBounds(c, xroads, lot, lotWid, lotHgt) {
+    /* 0 is the road; no lots. */
+    if (lot.x === 0 || lot.y === 0)
+        return { west: 0, north: 0, east: 0, south: 0 };
+    let west;
+    let east;
+    let north;
+    let south;
+    if (lot.x < 0) {
+        west = Math.max(2, xroads.x - 1 + lot.x * lotWid);
+        east = Math.min(c.width - 3, xroads.x - 2 + (lot.x + 1) * lotWid);
+    }
+    else {
+        west = Math.max(2, xroads.x + 2 + (lot.x - 1) * lotWid);
+        east = Math.min(c.width - 3, xroads.x + 1 + lot.x * lotWid);
+    }
+    if (lot.y < 0) {
+        north = Math.max(2, xroads.y + lot.y * lotHgt);
+        south = Math.min(c.height - 3, xroads.y - 1 + (lot.y + 1) * lotHgt);
+    }
+    else {
+        north = Math.max(2, xroads.y + 2 + (lot.y - 1) * lotHgt);
+        south = Math.min(c.height - 3, xroads.y + 1 + lot.y * lotHgt);
+    }
+    return { west, north, east, south };
+}
+/** lot_is_clear (gen-cave.c L2273): the lot is big enough and all floor. */
+function lotIsClear(c, xroads, lot, lotWid, lotHgt) {
+    const b = getLotBounds(c, xroads, lot, lotWid, lotHgt);
+    if (b.east - b.west < lotWid - 1 || b.south - b.north < lotHgt - 1)
+        return false;
+    for (let x = b.west; x <= b.east; x++) {
+        for (let y = b.north; y <= b.south; y++) {
+            if (!c.isFloor(loc(x, y)))
+                return false;
+        }
+    }
+    return true;
+}
+/** lot_has_shop (gen-cave.c L2295): the lot already contains a shop entrance. */
+function lotHasShop(c, xroads, lot, lotWid, lotHgt) {
+    const b = getLotBounds(c, xroads, lot, lotWid, lotHgt);
+    for (let x = b.west; x <= b.east; x++) {
+        for (let y = b.north; y <= b.south; y++) {
+            if (c.isShop(loc(x, y)))
+                return true;
+        }
+    }
+    return false;
+}
+/** build_store (gen-cave.c L2322): lay one store's building + door for shop n. */
+function buildStore(g, n, xroads, lot, lotWid, lotHgt) {
+    const c = g.c;
+    const rng = g.rng;
+    const { west: lotW, north: lotN, east: lotE, south: lotS } = getLotBounds(c, xroads, lot, lotWid, lotHgt);
+    let doorX = 0;
+    let doorY = 0;
+    let buildW = 0;
+    let buildN = 0;
+    let buildE = 0;
+    let buildS = 0;
+    if (lot.x < -1 || lot.x > 1) {
+        /* on the east west street */
+        if (lot.y === -1) {
+            /* north side of street */
+            doorY = macroMax(lotN + 1, () => lotS - rng.randint0(2));
+            buildS = doorY;
+            buildN = doorY - 2;
+        }
+        else {
+            /* south side */
+            doorY = macroMin(lotS - 1, () => lotN + rng.randint0(2));
+            buildN = doorY;
+            buildS = doorY + 2;
+        }
+        doorX = rng.randRange(lotW + 1, lotE - 2);
+        buildW = rng.randRange(Math.max(lotW, doorX - 2), doorX);
+        if (!c.isFloor(loc(buildW - 1, doorY))) {
+            buildW++;
+            doorX = Math.max(doorX, buildW);
+        }
+        buildE = rng.randRange(buildW + 2, Math.min(doorX + 2, lotE));
+        if (buildE - buildW > 1 && !c.isFloor(loc(buildE + 1, doorY))) {
+            buildE--;
+            doorX = Math.min(doorX, buildE);
+        }
+    }
+    else if (lot.y < -1 || lot.y > 1) {
+        /* on the north - south street */
+        if (lot.x === -1) {
+            /* west side of street */
+            doorX = macroMax(lotW + 1, () => lotE - rng.randint0(2) - rng.randint0(2));
+            buildE = doorX;
+            buildW = doorX - 2;
+        }
+        else {
+            /* east side */
+            doorX = macroMin(lotE - 1, () => lotW + rng.randint0(2) + rng.randint0(2));
+            buildW = doorX;
+            buildE = doorX + 2;
+        }
+        doorY = rng.randRange(lotN, lotS - 1);
+        buildN = rng.randRange(Math.max(lotN, doorY - 2), doorY);
+        if (!c.isFloor(loc(doorX, buildN - 1))) {
+            buildN++;
+            doorY = Math.max(doorY, buildN);
+        }
+        buildS = rng.randRange(Math.max(buildN + 1, doorY), Math.min(lotS, doorY + 2));
+        if (buildS - buildN > 1 && !c.isFloor(loc(doorX, buildS + 1))) {
+            buildS--;
+            doorY = Math.min(doorY, buildS);
+        }
+    }
+    else {
+        /* corner store */
+        if (lot.x < 0) {
+            /* west side */
+            doorX = lotE - 1 - rng.randint0(2);
+            buildE = macroMin(lotE, () => doorX + rng.randint0(2));
+            buildW = rng.randRange(Math.max(lotW, doorX - 2), buildE - 2);
+        }
+        else {
+            /* east side */
+            doorX = lotW + 1 + rng.randint0(2);
+            buildW = macroMax(lotW, () => doorX - rng.randint0(2));
+            buildE = rng.randRange(buildW + 2, Math.min(lotE, doorX + 2));
+        }
+        if (lot.y < 0) {
+            /* north side */
+            doorY = lotS - rng.randint0(2);
+            if (buildE === doorX || buildW === doorX) {
+                buildS = doorY + rng.randint0(2);
+            }
+            else {
+                /* Avoid encapsulating door */
+                buildS = doorY;
+            }
+            buildN = Math.max(lotN, doorY - 2);
+            if (buildS - buildN > 1 && !c.isFloor(loc(doorX, buildN - 1))) {
+                buildN++;
+                doorY = Math.max(buildN, doorY);
+            }
+        }
+        else {
+            /* south side */
+            doorY = lotN + rng.randint0(2);
+            if (buildE === doorX || buildW === doorX) {
+                buildN = doorY - rng.randint0(2);
+            }
+            else {
+                /* Avoid encapsulating door */
+                buildN = doorY;
+            }
+            buildS = Math.min(lotS, doorY + 2);
+            if (buildS - buildN > 1 && !c.isFloor(loc(doorX, buildS + 1))) {
+                buildS--;
+                doorY = Math.min(buildS, doorY);
+            }
+        }
+        /* Avoid placing buildings without space between them */
+        if (lot.x < 0 && buildE - buildW > 1 && !c.isFloor(loc(buildW - 1, doorY))) {
+            buildW++;
+            doorX = Math.max(doorX, buildW);
+        }
+        else if (lot.x > 0 &&
+            buildE - buildW > 1 &&
+            !c.isFloor(loc(buildE + 1, doorY))) {
+            buildE--;
+            doorX = Math.min(doorX, buildE);
+        }
+    }
+    buildW = Math.max(buildW, lotW);
+    buildE = Math.min(buildE, lotE);
+    buildN = Math.max(buildN, lotN);
+    buildS = Math.min(buildS, lotS);
+    /* Build an invulnerable rectangular building */
+    fillRectangle(c, buildN, buildW, buildS, buildE, FEAT.PERM, SQUARE.NONE);
+    /* Clear previous contents, add a store door (the feature whose shopnum is
+     * n + 1; TOWN_STORE_FEATS is that store-index -> feature mapping). */
+    c.setFeat(loc(doorX, doorY), TOWN_STORE_FEATS[n]);
+}
+/** build_ruin (gen-cave.c L2461): a ruined granite building spewing rubble. */
+function buildRuin(g, xroads, lot, lotWid, lotHgt) {
+    const c = g.c;
+    const rng = g.rng;
+    const b = getLotBounds(c, xroads, lot, lotWid, lotHgt);
+    const lotWest = b.west;
+    const lotNorth = b.north;
+    const lotEast = b.east;
+    const lotSouth = b.south;
+    if (lotEast - lotWest < 1 || lotSouth - lotNorth < 1)
+        return;
+    /* make a building */
+    const wid = rng.randRange(1, lotWid - 2);
+    const hgt = rng.randRange(1, lotHgt - 2);
+    const offsetX = rng.randRange(1, lotWid - 1 - wid);
+    const offsetY = rng.randRange(1, lotHgt - 1 - hgt);
+    const west = lotWest + offsetX;
+    const north = lotNorth + offsetY;
+    const south = lotSouth - (lotHgt - (hgt + offsetY));
+    const east = lotEast - (lotWid - (wid + offsetX));
+    fillRectangle(c, north, west, south, east, FEAT.GRANITE, SQUARE.NONE);
+    /* and then destroy it and spew rubble everywhere */
+    for (let x = lotWest; x <= lotEast; x++) {
+        for (let y = lotNorth; y <= lotSouth; y++) {
+            if (x >= west && x <= east && y >= north && y <= south) {
+                if (rng.randint0(4) === 0) {
+                    c.setFeat(loc(x, y), FEAT.RUBBLE);
+                }
+            }
+            else if (rng.randint0(3) === 0 &&
+                c.isFloor(loc(x, y)) &&
+                /* Avoid placing rubble next to a store */
+                (x > lotWest || x === 2 || !c.isPerm(loc(x - 1, y))) &&
+                (x < lotEast || x === c.width - 2 || !c.isPerm(loc(x + 1, y))) &&
+                (y > lotNorth || y === 2 || !c.isPerm(loc(x, y - 1))) &&
+                (y < lotSouth || y === c.height - 2 || !c.isPerm(loc(x, y + 1)))) {
+                c.setFeat(loc(x, y), FEAT.PASS_RUBBLE);
+            }
+        }
+    }
+}
+/**
+ * cave_illuminate (cave-map.c L555), the RNG-free flag-setting subset used at
+ * generation time: light (SQUARE_GLOW) every grid by day; by night keep only
+ * non-floor / bright terrain lit. Shop doorways are always lit. The
+ * player-knowledge side (square_memorize / square_forget) is a runtime concern
+ * and is applied by the live game (game/known.ts caveIlluminateKnown), not
+ * here. Exported so the runtime day/night boundary (game/loop.ts
+ * processWorld, via the WorldClockEnv.caveIlluminate hook installed in
+ * session/game.ts) can reuse this exact flag pass.
+ */
+export function caveIlluminate(c, daytime) {
+    for (let y = 0; y < c.height; y++) {
+        for (let x = 0; x < c.width; x++) {
+            const grid = loc(x, y);
+            if (daytime || !c.isFloor(grid)) {
+                c.sqinfoOn(grid, SQUARE.GLOW);
+            }
+            else if (!featIsBright(c.features, c.feat(grid))) {
+                c.sqinfoOff(grid, SQUARE.GLOW);
+            }
+        }
+    }
+    /* Light shop doorways. */
+    for (let y = 0; y < c.height; y++) {
+        for (let x = 0; x < c.width; x++) {
+            const grid = loc(x, y);
+            if (!c.isShop(grid))
+                continue;
+            for (let i = 0; i < 8; i++) {
+                const a = locSum(grid, DDGRID_DDD[i]);
+                if (c.inBounds(a))
+                    c.sqinfoOn(a, SQUARE.GLOW);
+            }
+        }
+    }
+}
+/**
+ * town_gen_layout (gen-cave.c L2515): build the town for the first time and
+ * return the north-wall crossroads head (pgrid) - where the single down stair
+ * sits and where the player is placed. Ported statement-by-statement so the
+ * RNG stream matches upstream draw-for-draw. Returns the player/stair grid.
+ */
+function townGenLayout(g) {
+    const c = g.c;
+    const rng = g.rng;
+    const townWid = c.width; /* z_info->town_wid */
+    const townHgt = c.height; /* z_info->town_hgt */
+    const storeMax = TOWN_STORE_FEATS.length; /* z_info->store_max */
+    const numLava = 3 + rng.randint0(3);
+    const ruinsPercent = 80;
+    const maxAttempts = 100;
+    const lotHgt = 4;
+    const lotWid = 6;
+    /* Declared outside the retry loop; NOT reset on a retry (upstream). */
+    let maxStoreY = 0;
+    let minStoreX = townWid;
+    let maxStoreX = 0;
+    /* Create walls */
+    drawRectangle(c, 0, 0, c.height - 1, c.width - 1, FEAT.PERM, SQUARE.NONE, true);
+    let pgrid = loc(0, 0);
+    let xroads = loc(0, 0);
+    let success = false;
+    while (!success) {
+        /* Initialize to ROCK for build_streamer precondition */
+        for (let y = 1; y < c.height - 1; y++) {
+            for (let x = 1; x < c.width - 1; x++) {
+                c.setFeat(loc(x, y), FEAT.GRANITE);
+            }
+        }
+        /* Make some lava streamers */
+        for (let n = 0; n < 3 + numLava; n++)
+            buildStreamer(g, FEAT.LAVA, 0);
+        /* Make a town-sized starburst room. */
+        generateStarburstRoom(g, 0, 0, c.height - 1, c.width - 1, false, FEAT.FLOOR, false);
+        /* Turn off room illumination flag */
+        for (let y = 1; y < c.height - 1; y++) {
+            for (let x = 1; x < c.width - 1; x++) {
+                c.sqinfoOff(loc(x, y), SQUARE.ROOM);
+            }
+        }
+        /* Stairs along north wall */
+        const px = rng.randSpread(Math.trunc(townWid / 2), Math.trunc(townWid / 6));
+        let py = 1;
+        while (!c.isFloor(loc(px, py)) && py < Math.trunc(townHgt / 4))
+            py++;
+        if (py >= Math.trunc(townHgt / 4))
+            continue;
+        pgrid = loc(px, py);
+        /* no lava next to stairs */
+        for (let x = px - 1; x <= px + 1; x++) {
+            for (let y = py - 1; y <= py + 1; y++) {
+                if (c.isFiery(loc(x, y)))
+                    c.setFeat(loc(x, y), FEAT.GRANITE);
+            }
+        }
+        const xrx = px;
+        const xry = Math.trunc(townHgt / 2) -
+            rng.randint0(Math.trunc(townHgt / 4)) +
+            rng.randint0(Math.trunc(townHgt / 8));
+        xroads = loc(xrx, xry);
+        const lotMinX = Math.trunc((-1 * xrx) / lotWid);
+        const lotMaxX = Math.trunc((townWid - xrx) / lotWid);
+        const lotMinY = Math.trunc((-1 * xry) / lotHgt);
+        const lotMaxY = Math.trunc((townHgt - xry) / lotHgt);
+        /* place stores along the streets */
+        let numAttempts = 0;
+        let exhausted = false;
+        for (let n = 0; n < storeMax; n++) {
+            let storeLot = loc(0, 0);
+            let foundSpot = false;
+            while (!foundSpot && numAttempts < maxAttempts) {
+                numAttempts++;
+                if (rng.randint0(2)) {
+                    /* east-west street */
+                    const sx = rng.randRange(lotMinX, lotMaxX);
+                    const sy = rng.randint0(2) ? 1 : -1;
+                    storeLot = loc(sx, sy);
+                }
+                else {
+                    /* north-south street */
+                    const sx = rng.randint0(2) ? 1 : -1;
+                    const sy = rng.randRange(lotMinY, lotMaxY);
+                    storeLot = loc(sx, sy);
+                }
+                if (storeLot.y === 0 || storeLot.x === 0)
+                    continue;
+                foundSpot = lotIsClear(c, xroads, storeLot, lotWid, lotHgt);
+            }
+            if (numAttempts >= maxAttempts) {
+                exhausted = true;
+                break;
+            }
+            maxStoreY = Math.max(maxStoreY, xry + lotHgt * storeLot.y);
+            minStoreX = Math.min(minStoreX, xrx + lotWid * storeLot.x);
+            maxStoreX = Math.max(maxStoreX, xrx + lotWid * storeLot.x);
+            buildStore(g, n, xroads, storeLot, lotWid, lotHgt);
+        }
+        if (exhausted)
+            continue;
+        /* place ruins */
+        for (let x = lotMinX; x <= lotMaxX; x++) {
+            if (x === 0)
+                continue; /* 0 is the street */
+            for (let y = lotMinY; y <= lotMaxY; y++) {
+                if (y === 0)
+                    continue;
+                if (rng.randint0(100) > ruinsPercent)
+                    continue;
+                if (rng.oneIn(2) && !lotHasShop(c, xroads, loc(x, y), lotWid, lotHgt)) {
+                    buildRuin(g, xroads, loc(x, y), lotWid, lotHgt);
+                }
+            }
+        }
+        success = true;
+    }
+    /* clear the street */
+    c.setFeat(loc(pgrid.x, pgrid.y + 1), FEAT.FLOOR);
+    fillRectangle(c, pgrid.y + 2, pgrid.x - 1, maxStoreY, pgrid.x + 1, FEAT.FLOOR, SQUARE.NONE);
+    fillRectangle(c, xroads.y, minStoreX, xroads.y + 1, maxStoreX, FEAT.FLOOR, SQUARE.NONE);
+    /* Clear previous contents, add down stairs */
+    c.setFeat(pgrid, FEAT.MORE);
+    return pgrid;
+}
+/**
+ * chunk_write (gen-chunk.c:46-61): terrain + sqinfo only, for the town store.
+ */
+export function chunkWriteTerrain(src) {
+    const out = new Chunk(src.features, src.height, src.width);
+    /* chunk_write "Town" name (generate.c:1371 / gen-chunk.c:46). */
+    out.name = "Town";
+    out.depth = src.depth;
+    for (let y = 0; y < src.height; y++) {
+        for (let x = 0; x < src.width; x++) {
+            const grid = loc(x, y);
+            out.setFeat(grid, src.feat(grid));
+            out.info(grid).copy(src.info(grid));
+        }
+    }
+    return out;
+}
+/**
+ * The town builder (town_gen, gen-cave.c L2664): first-time layout via
+ * town_gen_layout, or re-entry from a stored Town chunk (L2682-2703). Store
+ * entrances are non-passable shop terrain. Day/night is honoured when the
+ * caller supplies ctx.daytime; when omitted it defaults to daytime (turn 0).
+ */
+export const townGen = (ctx) => {
+    const { constants } = ctx;
+    const daytime = ctx.daytime ?? true;
+    const stored = ctx.townLayout ?? null;
+    if (stored) {
+        /* town_gen re-entry (gen-cave.c:2682-2703): copy stored terrain. */
+        const c = new Chunk(ctx.reg, stored.height, stored.width);
+        c.depth = stored.depth;
+        const g = makeGen(ctx, c);
+        for (let y = 0; y < stored.height; y++) {
+            for (let x = 0; x < stored.width; x++) {
+                const grid = loc(x, y);
+                c.setFeat(grid, stored.feat(grid));
+                c.info(grid).copy(stored.info(grid));
+            }
+        }
+        /* Find the stairs (gen-cave.c:2691-2700). */
+        let pgrid = loc(1, 1);
+        outer: for (let y = 0; y < c.height; y++) {
+            for (let x = 0; x < c.width; x++) {
+                if (c.feat(loc(x, y)) === FEAT.MORE) {
+                    pgrid = loc(x, y);
+                    break outer;
+                }
+            }
+        }
+        g.playerSpot = pgrid;
+        caveIlluminate(c, daytime);
+        const residents = daytime
+            ? constants.townMonstersDay
+            : constants.townMonstersNight;
+        for (let i = 0; i < residents; i++) {
+            pickAndPlaceDistantMonster(g, pgrid, 3, true, c.depth);
+        }
+        return { gen: g, error: null };
+    }
+    const c = new Chunk(ctx.reg, constants.townHgt, constants.townWid);
+    c.depth = ctx.depth;
+    const g = makeGen(ctx, c);
+    /* Build the layout and place the player at the crossroads head. */
+    const pgrid = townGenLayout(g);
+    g.playerSpot = pgrid;
+    /* Apply illumination. */
+    caveIlluminate(c, daytime);
+    /* Make some residents. */
+    const residents = daytime
+        ? constants.townMonstersDay
+        : constants.townMonstersNight;
+    for (let i = 0; i < residents; i++) {
+        pickAndPlaceDistantMonster(g, pgrid, 3, true, c.depth);
+    }
+    return { gen: g, error: null };
+};
+/* ------------------------------------------------------------------ *
+ * Stairs (handle_level_stairs, gen-cave.c:943-967).
+ * ------------------------------------------------------------------ */
+function handleLevelStairs(g, quest, downCount, upCount) {
+    const dun = g.dun;
+    const persistent = dun.persist;
+    /*
+     * For persistent levels, require the stairs be at least four grids apart so
+     * the connecting level's staircase rooms won't overlap; for both cases also
+     * require 1/4 of the shorter dimension so they don't all land in one room.
+     */
+    const minsep = Math.max(Math.trunc(Math.min(g.c.width, g.c.height) / 4), persistent ? 4 : 0);
+    /* For a persistent level whose neighbour already exists, that neighbour's
+     * staircase rooms already placed the matching stairs here via the seeded
+     * dun.join, so skip alloc_stairs for that direction (gen-cave.c:959-966). */
+    if (!persistent || !dun.hasAdjacentBelow) {
+        allocStairs(g, FEAT.MORE, downCount, minsep, false, dun.oneOffBelow, quest);
+    }
+    if (!persistent || !dun.hasAdjacentAbove) {
+        allocStairs(g, FEAT.LESS, upCount, minsep, false, dun.oneOffAbove, quest);
+    }
+}
+/* ------------------------------------------------------------------ *
+ * Context construction (attach profile tun/str shortcuts to Gen).
+ * ------------------------------------------------------------------ */
+function makeGen(ctx, c) {
+    const g = new Gen(c, ctx.rng, ctx.reg, ctx.constants, ctx.dun, ctx.objDeps, ctx.monDeps, ctx.trapKinds ?? null);
+    /* Attach the current profile's tunnel/streamer parameters for the tunnel
+     * and streamer helpers (they are read-only during a build). */
+    g.profileTun = ctx.profile.tun;
+    /* new_player_spot's placement-failure message (gen-util.c:422). */
+    if (ctx.msg)
+        g.msg = ctx.msg;
+    g.profileStr = ctx.profile.str;
+    /* dun->profile = choose_profile(p) (generate.c L1157): help_greater_vault
+     * (gen-room.c L3099) compares dun->profile->name against "classic". */
+    ctx.dun.profileName = ctx.profile.name;
+    return g;
+}
+/* ------------------------------------------------------------------ *
+ * Dungeon profile registry + selection (choose_profile).
+ * ------------------------------------------------------------------ */
+/** labyrinth_check: d_m's prime-number labyrinth acceptance. */
+function labyrinthCheck(rng, depth) {
+    let chance = 2;
+    if (depth < 13)
+        return false;
+    if (depth % 3 === 0)
+        chance += 1;
+    if (depth % 5 === 0)
+        chance += 1;
+    if (depth % 7 === 0)
+        chance += 1;
+    if (depth % 11 === 0)
+        chance += 1;
+    if (depth % 13 === 0)
+        chance += 1;
+    if (rng.randint0(100) >= chance)
+        return false;
+    return true;
+}
+/**
+ * The dungeon-profile registry: a string-keyed set of cave builders plus the
+ * ordered profile list used for selection. Both are runtime-registrable so a
+ * mod can add a builder and/or a whole new profile.
+ */
+export class DungeonProfiles {
+    builders = new Map();
+    profiles = [];
+    registerBuilder(key, builder) {
+        this.builders.set(key, builder);
+    }
+    builder(key) {
+        const b = this.builders.get(key);
+        if (!b)
+            throw new Error(`gen: no cave builder registered for '${key}'`);
+        return b;
+    }
+    hasBuilder(key) {
+        return this.builders.has(key);
+    }
+    addProfile(profile) {
+        this.profiles.push(profile);
+    }
+    find(name) {
+        return this.profiles.find((p) => p.name === name) ?? null;
+    }
+    list() {
+        return this.profiles;
+    }
+    /** choose_profile: select a dungeon profile for the given depth. */
+    choose(rng, depth, options = {}) {
+        const quest = options.quest ?? false;
+        const moria = this.find("moria");
+        const labyrinth = this.find("labyrinth");
+        const moriaAlloc = moria ? moria.alloc : 0;
+        const labyrinthAlloc = labyrinth ? labyrinth.alloc : 0;
+        /* The NOSCORE_JUMPING request, ahead of every other rule (L824-836). */
+        if (options.name) {
+            const named = this.find(options.name);
+            if (named)
+                return named;
+        }
+        let profile = null;
+        if (depth === 0) {
+            profile = this.find("town");
+        }
+        else if (quest) {
+            profile = this.find("classic");
+        }
+        else if (labyrinthCheck(rng, depth) && (labyrinthAlloc > 0 || labyrinthAlloc === -1)) {
+            profile = labyrinth;
+        }
+        else if (depth >= 10 && depth < 40 && rng.oneIn(40) && (moriaAlloc > 0 || moriaAlloc === -1)) {
+            profile = moria;
+        }
+        else {
+            let totalAlloc = 0;
+            for (const test of this.profiles) {
+                if (test.alloc <= 0 || depth < test.minLevel)
+                    continue;
+                totalAlloc += test.alloc;
+                if (rng.randint0(totalAlloc) < test.alloc)
+                    profile = test;
+            }
+            if (!profile)
+                profile = this.find("classic");
+        }
+        if (!profile)
+            profile = this.find("classic");
+        if (!profile)
+            throw new Error("gen: failed to find a cave profile");
+        return profile;
+    }
+}
+/**
+ * Build the default dungeon-profile registry: a real cave builder for every
+ * upstream key (town/classic/modified/labyrinth/cavern/moria/lair/gauntlet/
+ * hard_centre - all faithful ports now) plus every dungeon_profile.txt profile,
+ * loaded in file order so choose_profile's weighted selection matches upstream.
+ * Mods extend both via registerBuilder/addProfile. (arena is quest-only and not
+ * a dungeon profile; it lives with the deferred quest system.)
+ */
+export function createDungeonProfiles(profileRecords) {
+    const reg = new DungeonProfiles();
+    reg.registerBuilder("classic", classicGen);
+    reg.registerBuilder("modified", modifiedGen);
+    reg.registerBuilder("town", townGen);
+    reg.registerBuilder("labyrinth", labyrinthGen);
+    reg.registerBuilder("cavern", cavernGen);
+    reg.registerBuilder("moria", moriaGen);
+    reg.registerBuilder("lair", lairGen);
+    reg.registerBuilder("gauntlet", gauntletGen);
+    reg.registerBuilder("hard_centre", hardCentreGen);
+    /* Load EVERY dungeon profile (choose_profile, generate.c L813): town at
+     * depth 0, quest -> classic, labyrinth_check and the depth 10-40 one_in_(40)
+     * moria as forced/special, then the weighted alloc/min-level pass over the
+     * rest. Profiles are added in dungeon_profile.txt order, which the weighted
+     * loop's running-total randint0 relies on for faithful selection + RNG. */
+    for (const rec of profileRecords) {
+        reg.addProfile(loadDunProfile(rec));
+    }
+    return reg;
+}
+//# sourceMappingURL=cave.js.map