Rebuild map bundle: Forgotten Plains cliff stair exits

Picks up the auto-battler change adding narrow + wide stone stair exits to
every cliff edge (stairTileAt in bakeCliffs).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

web/mapSandbox.js

@@ -710,10 +710,67 @@ function centerTile([c0, r0], dNW, dNE, dSW, dSE) {
   if (dSW) return [c0, r0 + 4];
   return [c0 + 1, r0 + 4];
 }
-function bakeCliffs(cfg, { chunk, x0, y0, seed, raised, place, accept = () => true }) {
+function bakeCliffs(cfg, { chunk, x0, y0, seed, raised, place, accept = () => true, stairAt = null, stairAtV = null }) {
+  const ST = cfg.STAIR && (stairAt || stairAtV) ? cfg.STAIR : null;
+  const useNS = ST && stairAt, useWE = ST && stairAtV;
+  const isWide = (ax, ay, room) => room && rhash(ax, ay, ST.WIDE_SALT, seed) % 2 === 0;
+  const sAnchor = (x, y) => raised(x, y) && !raised(x, y + 1) && raised(x - 1, y) && raised(x + 1, y) && stairAt(x, y);
+  const nAnchor = (x, y) => raised(x, y) && !raised(x, y - 1) && raised(x - 1, y) && raised(x + 1, y) && stairAt(x, y);
+  const wAnchor = (x, y) => raised(x, y) && !raised(x - 1, y) && raised(x + 1, y) && raised(x, y - 1) && raised(x, y + 1) && !raised(x - 1, y + 1) && stairAtV(x, y);
+  const eAnchor = (x, y) => raised(x, y) && !raised(x + 1, y) && raised(x - 1, y) && raised(x, y - 1) && raised(x, y + 1) && !raised(x + 1, y + 1) && stairAtV(x, y);
+  const sRoom = (x, y) => !raised(x + 1, y + 1) && raised(x + 2, y) && !raised(x + 2, y + 1) && raised(x + 3, y);
+  const nRoom = (x, y) => !raised(x + 1, y - 1) && raised(x + 2, y) && !raised(x + 2, y - 1) && raised(x + 3, y);
+  const wRoom = (x, y) => raised(x, y + 2) && !raised(x - 1, y + 2);
+  const eRoom = (x, y) => raised(x, y + 2) && !raised(x + 1, y + 2);
+  const W_OFF = [[0, 0], [0, 1], [-1, 0], [-1, 1], [-1, 2]];
+  const E_OFF = [[0, 0], [0, 1], [1, 0], [1, 1], [1, 2]];
+  const sDepth = useNS ? Math.max(ST.S.NARROW.length, ST.S.WIDE.length) : 0;
+  function stairTileAt(wx, wy) {
+    if (useNS) {
+      for (let drow = 0; drow < sDepth; drow++) for (let dcol = 0; dcol <= 2; dcol++) {
+        const ax = wx - dcol, ay = wy - drow;
+        if (!sAnchor(ax, ay)) continue;
+        if (isWide(ax, ay, sRoom(ax, ay))) {
+          if (drow < ST.S.WIDE.length) return ST.S.WIDE[drow][dcol];
+        } else if (dcol === 0 && drow < ST.S.NARROW.length) return ST.S.NARROW[drow];
+      }
+      for (let dcol = 0; dcol <= 2; dcol++) {
+        if (nAnchor(wx - dcol, wy)) {
+          if (isWide(wx - dcol, wy, nRoom(wx - dcol, wy))) return ST.N.WIDE.LIP[dcol];
+          if (dcol === 0) return ST.N.NARROW.LIP;
+        }
+        if (nAnchor(wx - dcol, wy + 1)) {
+          if (isWide(wx - dcol, wy + 1, nRoom(wx - dcol, wy + 1))) return ST.N.WIDE.CAP[dcol];
+          if (dcol === 0) return ST.N.NARROW.CAP;
+        }
+      }
+    }
+    if (useWE) {
+      for (const [dx, dy] of W_OFF) {
+        const ax = wx - dx, ay = wy - dy;
+        if (!wAnchor(ax, ay)) continue;
+        const e = (isWide(ax, ay, wRoom(ax, ay)) ? ST.W.WIDE : ST.W.NARROW).find((o) => o.dx === dx && o.dy === dy);
+        if (e) return e.t;
+      }
+      for (const [dx, dy] of E_OFF) {
+        const ax = wx - dx, ay = wy - dy;
+        if (!eAnchor(ax, ay)) continue;
+        const e = (isWide(ax, ay, eRoom(ax, ay)) ? ST.E.WIDE : ST.E.NARROW).find((o) => o.dx === dx && o.dy === dy);
+        if (e) return e.t;
+      }
+    }
+    return null;
+  }
   for (let ty = 0; ty < chunk; ty++) for (let tx = 0; tx < chunk; tx++) {
     if (!accept(tx, ty)) continue;
     const wx = x0 + tx, wy = y0 + ty;
+    if (ST) {
+      const st = stairTileAt(wx, wy);
+      if (st) {
+        place(st, tx, ty);
+        continue;
+      }
+    }
     if (raised(wx, wy)) {
       const bN = !raised(wx, wy - 1), bE = !raised(wx + 1, wy), bS = !raised(wx, wy + 1), bW = !raised(wx - 1, wy);
       if (bN && bW) place(cfg.LIP_TL, tx, ty);
@@ -977,8 +1034,54 @@ var FP_CLIFF = {
   FACE_VAR: [[], []],
   FACE_L: [[24, 19], [24, 20]],
   FACE_R: [[26, 19], [26, 20]],
-  RATE: 4
+  RATE: 4,
+  // Stair exits cut into straight cliff edges. Two sheet variants, one tile wide (cross at cols 2–6)
+  // and two tiles wide (cross at cols 8–14); bakeCliffs picks per-exit by hash. Every tile below is
+  // a real non-empty sheet cell — the crosses have transparent corners, so placing those would bleed
+  // the grass base through (the bug the NARROW arms used to hit). Layout per direction:
+  //   • S — NARROW: one column, [lip, step, step, step(onto ground)]. WIDE: 3 columns × those 4 rows.
+  //   • N — LIP on the raised back edge (grass+steps) + CAP one tile north on the ground; ×3 cols wide.
+  //   • W/E — a descent off the side wall. Each tile carries its {dx,dy} cell-offset from the wall
+  //     anchor. NARROW: 3-tile L. WIDE: 2-tall entry on the wall + a 3-tall stone descent beside it.
+  STAIR: {
+    WIDE_SALT: 359697,
+    // hash salt deciding narrow-vs-wide at each exit (~50/50)
+    S: {
+      NARROW: [[4, 18], [4, 19], [4, 20], [4, 20]],
+      WIDE: [
+        [[10, 19], [11, 19], [12, 19]],
+        [[10, 20], [11, 20], [12, 20]],
+        [[10, 21], [11, 21], [12, 21]],
+        [[10, 21], [11, 21], [12, 21]]
+      ]
+    },
+    N: {
+      NARROW: { LIP: [4, 16], CAP: [4, 15] },
+      WIDE: { LIP: [[10, 16], [11, 16], [12, 16]], CAP: [[10, 15], [11, 15], [12, 15]] }
+    },
+    W: {
+      NARROW: [{ dx: 0, dy: 0, t: [3, 17] }, { dx: -1, dy: 0, t: [2, 17] }, { dx: -1, dy: 1, t: [2, 18] }],
+      WIDE: [
+        { dx: 0, dy: 0, t: [9, 17] },
+        { dx: 0, dy: 1, t: [9, 18] },
+        { dx: -1, dy: 0, t: [8, 17] },
+        { dx: -1, dy: 1, t: [8, 18] },
+        { dx: -1, dy: 2, t: [8, 19] }
+      ]
+    },
+    E: {
+      NARROW: [{ dx: 0, dy: 0, t: [5, 17] }, { dx: 1, dy: 0, t: [6, 17] }, { dx: 1, dy: 1, t: [6, 18] }],
+      WIDE: [
+        { dx: 0, dy: 0, t: [13, 17] },
+        { dx: 0, dy: 1, t: [13, 18] },
+        { dx: 1, dy: 0, t: [14, 17] },
+        { dx: 1, dy: 1, t: [14, 18] },
+        { dx: 1, dy: 2, t: [14, 19] }
+      ]
+    }
+  }
 };
+var STAIR_SPACING = 14;
 var COL_CLIFF = [150, 138, 112];
 var FOLIAGE = [
   { weight: 5, tiles: [[9, 6], [10, 6], [11, 6]] },
@@ -1260,7 +1363,15 @@ var fpConfig = (seed) => ({
       sp.y = ty * TILE3;
       tmp.addChild(sp);
     }
-    bakeCliffs(FP_CLIFF, { chunk: CHUNK2, x0, y0, seed: seed2, raised: isRaisedAt, place, accept });
+    const stairAt = (wx, wy) => {
+      const off = hashU32(seed2 ^ 358936, Math.floor(wy / STAIR_SPACING), 0) % STAIR_SPACING;
+      return ((wx - off) % STAIR_SPACING + STAIR_SPACING) % STAIR_SPACING === 0;
+    };
+    const stairAtV = (wx, wy) => {
+      const off = hashU32(seed2 ^ 358940, Math.floor(wx / STAIR_SPACING), 0) % STAIR_SPACING;
+      return ((wy - off) % STAIR_SPACING + STAIR_SPACING) % STAIR_SPACING === 0;
+    };
+    bakeCliffs(FP_CLIFF, { chunk: CHUNK2, x0, y0, seed: seed2, raised: isRaisedAt, place, accept, stairAt, stairAtV });
     if (ctx.props) {
       const inGrove = (wx, wy) => forestRegion[idx(wx - x0 + M, wy - y0 + M)] === 1;
       const bx0 = Math.floor(x0 / FOREST_BLOCK_X), bx1 = Math.floor((x0 + CHUNK2 - 1) / FOREST_BLOCK_X);
@@ -1273,13 +1384,14 @@ var fpConfig = (seed) => ({
         if (!inGrove(wx, wy)) continue;
         if ((h2 >>> 8 & 65535) / 65536 >= FOREST_FILL) continue;
         if (atW(wx, wy) || atS(wx, wy)) continue;
-        if (isRaisedAt(wx, wy)) continue;
-        let onFace = false;
-        for (let k = 1; k <= FP_CLIFF.FACE_H; k++) if (isRaisedAt(wx, wy - k)) {
-          onFace = true;
-          break;
+        if (!isRaisedAt(wx, wy)) {
+          let onFace = false;
+          for (let k = 1; k <= FP_CLIFF.FACE_H; k++) if (isRaisedAt(wx, wy - k)) {
+            onFace = true;
+            break;
+          }
+          if (onFace) continue;
         }
-        if (onFace) continue;
         const T = TREES[(h2 >>> 24) % TREES.length];
         const flip = (h2 >>> 20 & 255) / 256 < TREE_FLIP_RATE;
         const sc = TREE_SCALE_BASE * (1 + ((h2 >>> 12 & 255) / 256 - 0.5) * 2 * TREE_SCALE_JITTER);
@@ -1313,13 +1425,15 @@ var fpConfig = (seed) => ({
         if (!accept(wx - x0, wy - y0)) continue;
         if (!inClump(wx, wy)) continue;
         if ((h2 >>> 8 & 65535) / 65536 >= STONE_CLUMP_FILL) continue;
-        if (atW(wx, wy) || isRaisedAt(wx, wy)) continue;
-        let onFace = false;
-        for (let k = 1; k <= FP_CLIFF.FACE_H; k++) if (isRaisedAt(wx, wy - k)) {
-          onFace = true;
-          break;
+        if (atW(wx, wy)) continue;
+        if (!isRaisedAt(wx, wy)) {
+          let onFace = false;
+          for (let k = 1; k <= FP_CLIFF.FACE_H; k++) if (isRaisedAt(wx, wy - k)) {
+            onFace = true;
+            break;
+          }
+          if (onFace) continue;
         }
-        if (onFace) continue;
         let pick = (h2 >>> 20) % STONE_WEIGHT, st = STONES[0];
         for (const s of STONES) {
           if (pick < s.weight) {