@maka/maka-cli 5.49.0 → 5.51.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/room-grid.js

@@ -0,0 +1,742 @@
+import { Direction } from '../types/shared/direction-enum.js';
+export const METERS_PER_CELL = 2;
+export const METERS_PER_LEVEL = 3;
+export const key = (c) => `${c.x},${c.y},${c.z}`;
+/**
+ * x,y cell counts per size class -- 2 m/cell.
+ *
+ * RESIZED 2026-08-25 (playtest: "room sizes need to be tuned -- they
+ * are generally too small"). The original table was drawn when a spot
+ * was a single cell and bodies could stack on it; now furniture holds a
+ * real footprint (a bar runs three cells) and every actor needs a cell
+ * of its own, so the old `small` 4x3 spent two thirds of the room on
+ * fixtures and left four squares of floor. Each class moved up roughly
+ * one step:
+ *   tiny   4x3   =  8x6 m   -- a crypt, a cubicle, a back office
+ *   small  6x4   = 12x8 m   -- a shop, a hut, a back room
+ *   medium 8x6   = 16x12 m  -- a clinic, a chapel, a workshop
+ *   large  12x8  = 24x16 m  -- a bar, a turf hall, a market floor
+ *   huge   16x11 = 32x22 m  -- a street, a cavern, an atrium
+ * These also make SR5 p.185's range brackets bite indoors: a large
+ * room's diagonal is ~29 m, so a pistol (short 5, medium 20) is
+ * genuinely reaching across it.
+ */
+const SIZE_DIMS = {
+    tiny: { x: 4, y: 3 },
+    small: { x: 6, y: 4 },
+    medium: { x: 8, y: 6 },
+    large: { x: 12, y: 8 },
+    huge: { x: 16, y: 11 },
+};
+/** The x,y cell footprint a size class implies -- the same table
+ *  synthesis uses, exposed for DISPLAY-ONLY consumers that have no
+ *  grid to read (utilities/room-view.ts draws a spotless room's shell
+ *  from this; a spotless room never synthesizes a grid, THE COMPAT
+ *  RULE, and must not start doing so just to be drawn). */
+export function dimsForSize(size) {
+    return SIZE_DIMS[size ?? 'medium'];
+}
+// ============================== RNG ===================================
+/** FNV-1a, 32-bit. Deterministic string -> uint32. */
+export function hashFnv1a(str) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        h ^= str.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return h >>> 0;
+}
+/** mulberry32: tiny, fast, deterministic PRNG -- () => [0,1). */
+export function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+// =========================== Grid geometry =============================
+function cellExists(grid, c, levelCells) {
+    if (c.x < 0 || c.y < 0 || c.x >= grid.dims.x || c.y >= grid.dims.y)
+        return false;
+    if (c.z === 0)
+        return true;
+    return levelCells.get(c.z)?.has(`${c.x},${c.y}`) ?? false;
+}
+/** Whether `c` sits inside an uncleared BLOCKING terrain region. */
+function isBlocked(grid, c) {
+    const k = key(c);
+    for (const region of grid.terrain.values()) {
+        if (!region.blocking || region.cleared)
+            continue;
+        if (region.cells.some(rc => key(rc) === k))
+            return true;
+    }
+    return false;
+}
+/** Whether an uncleared blocking region seals this cell -- the same
+ *  test pathing uses, exposed so spots.ts can seat bodies only on
+ *  ground they could actually stand on. */
+export function isCellBlocked(grid, c) {
+    return isBlocked(grid, c);
+}
+/** 8-connected same-level neighbors plus any vertical links touching
+ *  this cell (both directions -- climb difficulty is move.ts's job). */
+function neighborsOf(grid, c, levelCells, rules) {
+    const out = [];
+    const open = (n) => cellExists(grid, n, levelCells) && !isBlocked(grid, n) && !rules.occupied?.has(key(n));
+    for (let dx = -1; dx <= 1; dx++) {
+        for (let dy = -1; dy <= 1; dy++) {
+            if (dx === 0 && dy === 0)
+                continue;
+            const n = { x: c.x + dx, y: c.y + dy, z: c.z };
+            if (open(n))
+                out.push(n);
+        }
+    }
+    const up = grid.vertical.get(key(c));
+    if (up && !(rules.avoidClimb && up.kind === 'climb')) {
+        const target = { x: c.x, y: c.y, z: up.toZ };
+        if (open(target))
+            out.push(target);
+    }
+    for (const [fromKey, link] of grid.vertical.entries()) {
+        if (link.toZ !== c.z)
+            continue;
+        if (rules.avoidClimb && link.kind === 'climb')
+            continue;
+        const [fx, fy, fz] = fromKey.split(',').map(Number);
+        if (fx === c.x && fy === c.y) {
+            const from = { x: fx, y: fy, z: fz };
+            if (open(from))
+                out.push(from);
+        }
+    }
+    return out;
+}
+function bfs(grid, from, to, levelCells, rules) {
+    const cameFrom = new Map();
+    const visited = new Set([key(from)]);
+    const queue = [from];
+    let qi = 0;
+    while (qi < queue.length) {
+        const cur = queue[qi++];
+        for (const n of neighborsOf(grid, cur, levelCells, rules)) {
+            const nk = key(n);
+            if (visited.has(nk))
+                continue;
+            visited.add(nk);
+            cameFrom.set(nk, cur);
+            if (nk === key(to)) {
+                const path = [to];
+                let walk = nk;
+                while (walk !== key(from)) {
+                    const prev = cameFrom.get(walk);
+                    path.push(prev);
+                    walk = key(prev);
+                }
+                return path.reverse();
+            }
+            queue.push(n);
+        }
+    }
+    return undefined;
+}
+/** BFS shortest path between two cells, or undefined if unreachable
+ *  through open (non-blocked, in-bounds) cells. `levelCells` recomputed
+ *  from the grid's synthesis metadata (kept on the grid via a WeakMap
+ *  so callers never have to pass it around -- see synthesizeGrid).
+ *
+ * FOUR PASSES, cheapest-and-safest first. Two things are avoided when
+ * anything else will do, and they are NOT equally bad:
+ *  1. a 'climb' link is the RISKY alternative to a level's own stairs
+ *     or ladder (move.ts rolls Athletics on it, and a failure is a
+ *     fall), so it is the LAST thing given up;
+ *  2. a cell holding somebody's body is merely in the way -- squeezing
+ *     past a bystander beats free-climbing a wall every time.
+ * Hence: (no climb, no squeeze) -> (no climb, squeeze) -> (climb, no
+ * squeeze) -> (climb, squeeze). Bodies never make a destination
+ * unreachable on their own; the worst they can do is force a squeeze,
+ * which move.ts narrates. `pathSqueezes` tells a caller which
+ * happened. */
+export function findPath(grid, from, to, occupied) {
+    const levelCells = LEVEL_CELLS.get(grid) ?? new Map();
+    if (key(from) === key(to))
+        return [from];
+    // Never let the mover's own destination count as blocked by a body.
+    const bodies = occupied && occupied.size > 0 ? occupied : undefined;
+    return bfs(grid, from, to, levelCells, { avoidClimb: true, occupied: bodies })
+        ?? bfs(grid, from, to, levelCells, { avoidClimb: true })
+        ?? bfs(grid, from, to, levelCells, { avoidClimb: false, occupied: bodies })
+        ?? bfs(grid, from, to, levelCells, { avoidClimb: false });
+}
+/** Whether this route threads a cell somebody is standing in -- i.e.
+ *  findPath had to fall back past the no-squeeze passes. */
+export function pathSqueezes(path, occupied) {
+    if (!occupied || occupied.size === 0)
+        return false;
+    return path.some(c => occupied.has(key(c)));
+}
+/** Straight-line 3D distance in meters between two cells. */
+export function distanceMeters(a, b) {
+    const dx = (a.x - b.x) * METERS_PER_CELL;
+    const dy = (a.y - b.y) * METERS_PER_CELL;
+    const dz = (a.z - b.z) * METERS_PER_LEVEL;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+/** Every cell that exists at z-level `z`: ground (z=0) is implicitly the
+ *  whole x*y footprint; an upper level is only its declared strip. The
+ *  shape utilities/room-view.ts needs to draw each floor without
+ *  reaching into LEVEL_CELLS itself (module-private -- see
+ *  synthesizeGrid). Declared before LEVEL_CELLS below; fine at call
+ *  time (the const is bound long before any consumer runs). */
+export function levelFootprint(grid, z) {
+    if (z === 0) {
+        const out = [];
+        for (let x = 0; x < grid.dims.x; x++) {
+            for (let y = 0; y < grid.dims.y; y++)
+                out.push({ x, y, z: 0 });
+        }
+        return out;
+    }
+    const cells = LEVEL_CELLS.get(grid)?.get(z);
+    if (!cells)
+        return [];
+    return [...cells].map(k => { const [x, y] = k.split(',').map(Number); return { x, y, z }; });
+}
+/** Integer 3D Bresenham/DDA line between two cells (inclusive), used
+ *  for the supercover cover check -- deterministic and symmetric. */
+function line3D(a, b) {
+    const out = [];
+    let [x, y, z] = [a.x, a.y, a.z];
+    const dx = Math.abs(b.x - x), dy = Math.abs(b.y - y), dz = Math.abs(b.z - z);
+    const sx = Math.sign(b.x - x), sy = Math.sign(b.y - y), sz = Math.sign(b.z - z);
+    const steps = Math.max(dx, dy, dz);
+    if (steps === 0)
+        return [{ x, y, z }];
+    let errX = steps / 2, errY = steps / 2, errZ = steps / 2;
+    out.push({ x, y, z });
+    for (let i = 0; i < steps; i++) {
+        errX -= dx;
+        errY -= dy;
+        errZ -= dz;
+        if (errX < 0) {
+            x += sx;
+            errX += steps;
+        }
+        if (errY < 0) {
+            y += sy;
+            errY += steps;
+        }
+        if (errZ < 0) {
+            z += sz;
+            errZ += steps;
+        }
+        out.push({ x, y, z });
+    }
+    return out;
+}
+/** Cover between two cells: any uncleared terrain region (blocking OR
+ *  degraded-to-scenery -- both still occlude) whose cells intersect
+ *  the line of fire, excluding the two endpoints themselves. 'good'
+ *  wins over 'partial' when both are present. */
+export function coverBetween(grid, from, to) {
+    const line = line3D(from, to).slice(1, -1);
+    if (line.length === 0)
+        return undefined;
+    const lineKeys = new Set(line.map(key));
+    let best;
+    for (const region of grid.terrain.values()) {
+        if (region.cleared)
+            continue;
+        if (region.cells.some(c => lineKeys.has(key(c)))) {
+            if (region.cover === 'good')
+                return 'good';
+            best = 'partial';
+        }
+    }
+    return best;
+}
+/** Which uncleared blocking region is sealing the path from `from` to
+ *  `to`: re-runs BFS with each candidate region's cells excluded, and
+ *  returns the smallest one whose removal opens a path. Undefined when
+ *  no path exists even with every region cleared (a genuinely
+ *  disconnected room -- a synthesis bug, not a player-facing state). */
+export function blockingRegionFor(grid, from, to) {
+    const candidates = [...grid.terrain.values()]
+        .filter(r => r.blocking && !r.cleared)
+        .sort((a, b) => a.cells.length - b.cells.length);
+    for (const region of candidates) {
+        const trial = { ...grid, terrain: new Map(grid.terrain) };
+        trial.terrain.set(region.id, { ...region, cleared: true });
+        LEVEL_CELLS.set(trial, LEVEL_CELLS.get(grid) ?? new Map());
+        if (findPath(trial, from, to))
+            return region;
+    }
+    return undefined;
+}
+/** SR5 p.172 (RAG-verified): DV = meters fallen, only beyond 3m; AP-4
+ *  applies at the caller (resisted with Body+Armor -- move.ts's job). */
+export function fallDamageDV(zSteps) {
+    const meters = zSteps * METERS_PER_LEVEL;
+    return meters > 3 ? meters : 0;
+}
+/** Does this path cross a 'climb' vertical link (the riskier route --
+ *  stairs/ladder never roll anything)? Returns the z-delta of the
+ *  riskiest crossing (for fallDamageDV), or undefined when the path
+ *  never touches one. */
+export function pathClimbSteps(grid, path) {
+    let steps;
+    for (let i = 0; i < path.length - 1; i++) {
+        const a = path[i], b = path[i + 1];
+        if (a.z === b.z)
+            continue;
+        const [lo, hi] = a.z < b.z ? [a, b] : [b, a];
+        const link = grid.vertical.get(key(lo));
+        if (link && link.toZ === hi.z && link.kind === 'climb') {
+            steps = Math.max(steps ?? 0, hi.z - lo.z);
+        }
+    }
+    return steps;
+}
+// ========================== Synthesis ===================================
+/** Per-grid metadata (which (x,y) cells exist at z>=1) that findPath's
+ *  cellExists needs but doesn't belong on the public IRoomGrid shape --
+ *  associated by identity so callers never juggle it themselves. */
+const LEVEL_CELLS = new WeakMap();
+const WALL_REGIONS = {
+    north: (d) => ({ x0: 0, x1: d.x - 1, y0: 0, y1: 0 }),
+    south: (d) => ({ x0: 0, x1: d.x - 1, y0: d.y - 1, y1: d.y - 1 }),
+    west: (d) => ({ x0: 0, x1: 0, y0: 0, y1: d.y - 1 }),
+    east: (d) => ({ x0: d.x - 1, x1: d.x - 1, y0: 0, y1: d.y - 1 }),
+    'northwest corner': (d) => ({ x0: 0, x1: Math.min(1, d.x - 1), y0: 0, y1: Math.min(1, d.y - 1) }),
+    'northeast corner': (d) => ({ x0: Math.max(0, d.x - 2), x1: d.x - 1, y0: 0, y1: Math.min(1, d.y - 1) }),
+    'southwest corner': (d) => ({ x0: 0, x1: Math.min(1, d.x - 1), y0: Math.max(0, d.y - 2), y1: d.y - 1 }),
+    'southeast corner': (d) => ({ x0: Math.max(0, d.x - 2), x1: d.x - 1, y0: Math.max(0, d.y - 2), y1: d.y - 1 }),
+    center: (d) => ({
+        x0: Math.max(0, Math.floor(d.x / 2) - 1), x1: Math.min(d.x - 1, Math.ceil(d.x / 2)),
+        y0: Math.max(0, Math.floor(d.y / 2) - 1), y1: Math.min(d.y - 1, Math.ceil(d.y / 2)),
+    }),
+};
+const FOOTPRINT_CELLS = { small: 2, medium: 4, large: 6 };
+/** Deterministic synthesis -- see the module doc for the contract.
+ *  Order of operations below IS the contract; never reorder without
+ *  bumping every consumer of the determinism guarantee. */
+export function synthesizeGrid(input) {
+    const rng = mulberry32(hashFnv1a(input.roomName));
+    const base = SIZE_DIMS[input.size ?? 'medium'];
+    const levels = (input.levels ?? []).slice(0, 2);
+    const dims = { x: base.x, y: base.y, z: levels.length + 1 }; // z=0 ground + each declared level
+    const levelCells = new Map();
+    const vertical = new Map();
+    const occupied = new Set(); // z=0 cells already claimed by a feature
+    levels.forEach((lvl, i) => {
+        const z = i + 1;
+        const region = WALL_REGIONS[lvl.side](base);
+        const cells = new Set();
+        for (let x = region.x0; x <= region.x1; x++) {
+            for (let y = region.y0; y <= region.y1; y++)
+                cells.add(`${x},${y}`);
+        }
+        levelCells.set(z, cells);
+        const stripCells = [...cells].map(k => { const [x, y] = k.split(',').map(Number); return { x, y }; });
+        if (stripCells.length === 0)
+            return;
+        // Stairs/ladder at one end of the strip (canon: stairwells sit in
+        // corners), a riskier "climb" cell at the other -- both keyed at
+        // GROUND (z=0), so multi-level rooms never depend on one level's
+        // strip overlapping another's.
+        const sorted = [...stripCells].sort((a, b) => (a.x + a.y) - (b.x + b.y));
+        const first = sorted[0];
+        const last = sorted[sorted.length - 1];
+        const kind = lvl.kind === 'catwalk' ? 'ladder' : 'stairs';
+        vertical.set(`${first.x},${first.y},0`, { kind, toZ: z });
+        occupied.add(`${first.x},${first.y},0`);
+        if (last.x !== first.x || last.y !== first.y) {
+            vertical.set(`${last.x},${last.y},0`, { kind: 'climb', toZ: z });
+            occupied.add(`${last.x},${last.y},0`);
+        }
+    });
+    const grid = {
+        dims, vertical, spotCells: new Map(), spotFootprints: new Map(),
+        exitCells: new Map(), terrain: new Map(),
+    };
+    LEVEL_CELLS.set(grid, levelCells);
+    const exists = (c) => cellExists(grid, c, levelCells);
+    const freeCellNear = (region, z) => {
+        const candidates = [];
+        for (let x = region.x0; x <= region.x1; x++) {
+            for (let y = region.y0; y <= region.y1; y++) {
+                const c = { x, y, z };
+                if (exists(c) && !occupied.has(key(c)))
+                    candidates.push(c);
+            }
+        }
+        if (candidates.length === 0)
+            return undefined;
+        return candidates[Math.floor(rng() * candidates.length)];
+    };
+    const claim = (c) => occupied.add(key(c));
+    // --- Exit cells: wall midpoint, jittered, collision-scanned. ---
+    const WALL_MID = {
+        north: () => ({ x: clamp(Math.floor(dims.x / 2) + jitter(rng), 0, dims.x - 1), y: 0, z: 0 }),
+        south: () => ({ x: clamp(Math.floor(dims.x / 2) + jitter(rng), 0, dims.x - 1), y: dims.y - 1, z: 0 }),
+        west: () => ({ x: 0, y: clamp(Math.floor(dims.y / 2) + jitter(rng), 0, dims.y - 1), z: 0 }),
+        east: () => ({ x: dims.x - 1, y: clamp(Math.floor(dims.y / 2) + jitter(rng), 0, dims.y - 1), z: 0 }),
+    };
+    const cardinalWall = { north: 'north', south: 'south', east: 'east', west: 'west' };
+    /** Exit cells each named spot serves -- seated after the loop below. */
+    const exitCellsBySpot = new Map();
+    for (const exit of input.exits) {
+        const wallSide = cardinalWall[exit.direction];
+        let cell;
+        if (wallSide) {
+            cell = WALL_MID[wallSide]();
+            cell = nearestFree(cell, occupied, dims, exists);
+        }
+        else {
+            // up/down (and anything exotic): no natural wall -- an open
+            // z=0 cell near the centroid, same free-cell picker as unplaced
+            // spots below.
+            const region = WALL_REGIONS.center(dims);
+            cell = freeCellNear(region, 0) ?? { x: 0, y: 0, z: 0 };
+        }
+        claim(cell);
+        grid.exitCells.set(exit.direction, cell);
+        if (exit.spotName) {
+            const served = exitCellsBySpot.get(exit.spotName) ?? [];
+            served.push(cell);
+            exitCellsBySpot.set(exit.spotName, served);
+        }
+    }
+    // KEEP THE DOORWAYS CLEAR. A doorway has exactly ONE cell it is
+    // reached from -- directly opposite it, one step in from its wall --
+    // so a fixture landing there does not decorate the room, it seals the
+    // exit (playtest 2026-08-25: "the counter is in the way of the door").
+    // Claiming the approach here puts it out of reach of every later
+    // placement pass: spot anchors, the off-wall nudge, and furniture
+    // growth all skip occupied cells.
+    const APPROACH_IN = {
+        [Direction.NORTH]: [0, 1], [Direction.SOUTH]: [0, -1],
+        [Direction.WEST]: [1, 0], [Direction.EAST]: [-1, 0],
+    };
+    for (const [direction, cell] of grid.exitCells.entries()) {
+        const step = APPROACH_IN[direction];
+        if (!step)
+            continue;
+        const approach = { x: cell.x + step[0], y: cell.y + step[1], z: cell.z };
+        if (exists(approach))
+            claim(approach);
+    }
+    // Seat each exit-serving spot, now that we know how many exits it
+    // serves. ONE exit: the spot IS that doorway, so it takes the cell
+    // (Mama Wu's "door" -> its east wall). SEVERAL: the spot is the hub
+    // they all open off -- Night Market's seed puts north, east AND south
+    // at the "stalls", and its prose says so ("the real shops open off
+    // the stalls") -- so it belongs in the MIDDLE of them, not welded to
+    // whichever exit the seed happened to list first (playtest
+    // 2026-08-25: "the stalls are to the north, but east and south
+    // directions also come off the stalls"). The doorways stay on their
+    // own walls; the hub sits where all of them are plausibly reachable.
+    for (const [spotName, served] of exitCellsBySpot.entries()) {
+        if (served.length === 1) {
+            grid.spotCells.set(spotName, served[0]);
+            continue;
+        }
+        const mid = {
+            x: clamp(Math.round(served.reduce((s, c) => s + c.x, 0) / served.length), 0, dims.x - 1),
+            y: clamp(Math.round(served.reduce((s, c) => s + c.y, 0) / served.length), 0, dims.y - 1),
+            z: 0,
+        };
+        const hub = nearestFree(mid, occupied, dims, exists);
+        claim(hub);
+        grid.spotCells.set(spotName, hub);
+    }
+    // --- Placed spots (place hint). ---
+    const unplaced = [];
+    for (const spot of input.spots) {
+        if (grid.spotCells.has(spot.name))
+            continue; // already an exit cell
+        if (!spot.place) {
+            unplaced.push(spot);
+            continue;
+        }
+        const z = clamp(spot.level ?? 0, 0, dims.z);
+        const region = WALL_REGIONS[spot.place](base);
+        const cell = freeCellNear(region, z) ?? freeCellNear(WALL_REGIONS.center(base), 0);
+        if (!cell) {
+            unplaced.push(spot);
+            continue;
+        }
+        claim(cell);
+        grid.spotCells.set(spot.name, cell);
+    }
+    // --- Unplaced spots: spread out (max-min distance, rejection sampled). ---
+    for (const spot of unplaced) {
+        let best;
+        let bestScore = -1;
+        for (let attempt = 0; attempt < 8; attempt++) {
+            const x = Math.floor(rng() * dims.x);
+            const y = Math.floor(rng() * dims.y);
+            const c = { x, y, z: 0 };
+            if (occupied.has(key(c)))
+                continue;
+            const placed = [...grid.spotCells.values()];
+            const minDist = placed.length === 0 ? Infinity : Math.min(...placed.map(p => chebyshev(p, c)));
+            if (minDist > bestScore) {
+                bestScore = minDist;
+                best = c;
+            }
+        }
+        if (!best)
+            best = fallbackFreeCell(dims, occupied);
+        if (best) {
+            claim(best);
+            grid.spotCells.set(spot.name, best);
+        }
+    }
+    // --- OPEN_FLOOR: nearest open z=0 cell to the centroid. ---
+    {
+        const cx = (dims.x - 1) / 2, cy = (dims.y - 1) / 2;
+        let best;
+        let bestDist = Infinity;
+        for (let x = 0; x < dims.x; x++) {
+            for (let y = 0; y < dims.y; y++) {
+                const c = { x, y, z: 0 };
+                const d = Math.hypot(x - cx, y - cy) + (occupied.has(key(c)) ? 0.01 : 0);
+                if (d < bestDist) {
+                    bestDist = d;
+                    best = c;
+                }
+            }
+        }
+        if (best)
+            grid.spotCells.set(OPEN_FLOOR_NAME, best);
+    }
+    // --- Furniture footprints: give each named place its real extent. ---
+    // Exit-bound spots stay ONE cell: that spot IS a doorway, and a
+    // doorway three cells wide would wall off its own threshold. The open
+    // floor is bare ground, never furniture.
+    const exitKeys = new Set([...grid.exitCells.values()].map(key));
+    for (const [name, anchor] of grid.spotCells.entries()) {
+        if (name === OPEN_FLOOR_NAME || exitKeys.has(key(anchor))) {
+            grid.spotFootprints.set(name, [anchor]);
+            continue;
+        }
+        const footprint = growFurniture(name, anchor, dims, occupied, exists, rng);
+        grid.spotFootprints.set(name, footprint);
+        // A served fixture may have been nudged off its wall -- the anchor
+        // IS the footprint's first cell, so keep the two in step.
+        grid.spotCells.set(name, footprint[0]);
+    }
+    const furnitureKeys = new Set([...grid.spotFootprints.entries()]
+        .filter(([n]) => n !== OPEN_FLOOR_NAME)
+        .flatMap(([, cells]) => cells.map(key)));
+    // --- Terrain regions: seal the guarded cell from the primary entry. ---
+    const primaryEntry = grid.exitCells.get(input.exits[0]?.direction) ?? grid.spotCells.get(OPEN_FLOOR_NAME);
+    for (const hint of input.terrainHints) {
+        const guarded = hint.guards.kind === 'exit'
+            ? grid.exitCells.get(hint.guards.direction)
+            : grid.spotCells.get(hint.guards.spotName);
+        if (!guarded || !primaryEntry)
+            continue;
+        const cover = hint.footprint === 'large' ? 'good' : 'partial';
+        let blocked = [];
+        let sealed = false;
+        // Rubble PREFERS to pile against the furniture rather than on top of
+        // it -- burying the bar would delete a place the room's prose names
+        // and the player can still "move to". But sealing the way is the
+        // contract and tidiness is not: if the clean pour can't close the
+        // ring (a fixture standing right where the rubble needed to go),
+        // the second pass is allowed to swallow furniture.
+        const openGround = (c) => exists(c) && !furnitureKeys.has(key(c));
+        for (const ground of [openGround, exists]) {
+            let cap = FOOTPRINT_CELLS[hint.footprint];
+            for (let round = 0; round < 3 && !sealed; round++) {
+                blocked = growBlob(grid, guarded, primaryEntry, cap, ground);
+                const region = {
+                    id: `terrain:${hint.puzzleName}`, label: hint.label, puzzleName: hint.puzzleName,
+                    cells: blocked, cleared: false, cover, blocking: true,
+                };
+                grid.terrain.set(region.id, region);
+                sealed = findPath(grid, primaryEntry, guarded) === undefined;
+                if (!sealed)
+                    cap += 2;
+                if (!sealed)
+                    grid.terrain.delete(region.id);
+            }
+            if (sealed)
+                break;
+        }
+        const finalRegion = {
+            id: `terrain:${hint.puzzleName}`, label: hint.label, puzzleName: hint.puzzleName,
+            cells: blocked, cleared: false, cover, blocking: sealed,
+        };
+        grid.terrain.set(finalRegion.id, finalRegion);
+        if (!sealed) {
+            console.error(`[room-grid] "${input.roomName}": terrain "${hint.puzzleName}" could not seal the guarded cell -- degraded to cover-only scenery.`);
+        }
+    }
+    return grid;
+}
+// Literal-coupled to spots.ts's OPEN_FLOOR (also 'open floor') --
+// deliberately not imported (this module stays spots.ts/Room-free, see
+// the module doc); Room.ensureGrid queries this cell by that same
+// string. A rename on either side must update both.
+export const OPEN_FLOOR_NAME = 'open floor';
+function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }
+function jitter(rng) { return Math.floor(rng() * 3) - 1; }
+function chebyshev(a, b) { return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)); }
+function nearestFree(start, occupied, dims, exists) {
+    if (exists(start) && !occupied.has(key(start)))
+        return start;
+    for (let r = 1; r < Math.max(dims.x, dims.y); r++) {
+        for (let dx = -r; dx <= r; dx++) {
+            for (let dy = -r; dy <= r; dy++) {
+                const c = { x: start.x + dx, y: start.y + dy, z: start.z };
+                if (exists(c) && !occupied.has(key(c)))
+                    return c;
+            }
+        }
+    }
+    return start;
+}
+function fallbackFreeCell(dims, occupied) {
+    for (let x = 0; x < dims.x; x++) {
+        for (let y = 0; y < dims.y; y++) {
+            const c = { x, y, z: 0 };
+            if (!occupied.has(key(c)))
+                return c;
+        }
+    }
+    return undefined;
+}
+/** How many cells a fixture fills, by what it IS. A bar runs the length
+ *  of its wall; a crate does not. Keyed on the words seeds actually
+ *  use; anything unrecognised stays a single cell, so an unknown spot
+ *  can never accidentally wall off a room. */
+const LONG_FIXTURES = /\b(bar|counter|rack|racks|shelv\w*|stall|stalls|booth|booths|bench|benches|workbench|pew|pews|row|rows|conveyor|catwalk)\b/i;
+const BULKY_FIXTURES = /\b(table|desk|console|terminal|crate|crates|cabinet|locker|lockers|bed|cot|pool|altar|forge|vat|tank)\b/i;
+/** Fixtures somebody stands BEHIND to work: they need a service lane,
+ *  so they never sit flush against a wall. See offWall/growFurniture. */
+const SERVED_FIXTURES = /\b(bar|counter|stall|stalls|desk|workbench|forge|altar)\b/i;
+/** Pulls a cell one square in from whichever wall it sits on, if that
+ *  square is free -- leaving a walkable lane on the far side. */
+function offWall(c, dims, occupied, exists) {
+    const inward = c.x === 0 ? [1, 0]
+        : c.x === dims.x - 1 ? [-1, 0]
+            : c.y === 0 ? [0, 1]
+                : c.y === dims.y - 1 ? [0, -1]
+                    : undefined;
+    if (!inward)
+        return c;
+    const moved = { x: c.x + inward[0], y: c.y + inward[1], z: c.z };
+    if (!exists(moved) || occupied.has(key(moved)))
+        return c;
+    occupied.delete(key(c));
+    occupied.add(key(moved));
+    return moved;
+}
+function furnitureExtent(name, dims) {
+    const room = Math.min(dims.x, dims.y);
+    const want = LONG_FIXTURES.test(name) ? 3 : BULKY_FIXTURES.test(name) ? 2 : 1;
+    // Never let furniture dominate a cramped room: a tiny room (3x2) has
+    // no business holding a three-cell bar.
+    return Math.max(1, Math.min(want, room - 1));
+}
+/**
+ * Grows a fixture from its anchor into a straight run of free cells
+ * (player ruling 2026-08-25: "bar, table, booths can have larger
+ * geometry than just one cell"). Straight, not blobby: real fixtures
+ * are lines against walls and slabs in the open, and a ragged blob
+ * would read as terrain rather than furniture. Picks the cardinal
+ * direction with the most free room -- which is what puts a bar ALONG
+ * its wall rather than jutting into the floor -- with fixed-order
+ * tie-breaks and one rng draw so the choice stays deterministic.
+ */
+function growFurniture(name, anchorIn, dims, occupied, exists, rng) {
+    const want = furnitureExtent(name, dims);
+    // A SERVED fixture needs two sides: one for whoever works it, one for
+    // whoever it serves (playtest 2026-08-25: "when furniture is placed
+    // in a room, the bartender should be on one side of it"). Flush
+    // against a wall there is only ever one side, and staff and customers
+    // pile onto it together -- so nudge it one cell off the wall and
+    // leave the service lane behind it.
+    const anchor = SERVED_FIXTURES.test(name) ? offWall(anchorIn, dims, occupied, exists) : anchorIn;
+    const cells = [anchor];
+    if (want <= 1)
+        return cells;
+    const DIRS = [[1, 0], [0, 1], [-1, 0], [0, -1]];
+    const runLength = (dx, dy) => {
+        let n = 0;
+        for (let i = 1; i < want; i++) {
+            const c = { x: anchor.x + dx * i, y: anchor.y + dy * i, z: anchor.z };
+            if (!exists(c) || occupied.has(key(c)))
+                break;
+            n++;
+        }
+        return n;
+    };
+    const scored = DIRS.map(([dx, dy]) => ({ dx, dy, run: runLength(dx, dy) }))
+        .sort((a, b) => b.run - a.run);
+    const best = scored[0];
+    if (!best || best.run === 0)
+        return cells;
+    // Break an exact tie with the room's own seed, so two identical
+    // fixtures don't always lie the same way.
+    const tied = scored.filter(s => s.run === best.run);
+    const pick = tied[Math.floor(rng() * tied.length)] ?? best;
+    for (let i = 1; i <= pick.run; i++) {
+        const c = { x: anchor.x + pick.dx * i, y: anchor.y + pick.dy * i, z: anchor.z };
+        occupied.add(key(c));
+        cells.push(c);
+    }
+    return cells;
+}
+const RING_OFFSETS = [
+    [-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1],
+];
+/** Grows a connected blob of up to `cap` open cells around `guarded`,
+ *  RING BY RING (the whole immediate 8-neighborhood before any 2nd-
+ *  ring cell) -- sealing a choke point means fully surrounding it, and
+ *  letting a farther-but-entry-closer cell jump the queue (a distance-
+ *  only priority queue would do exactly that) leaves a diagonal gap a
+ *  player just steps through. `entry`-distance only breaks ties WITHIN
+ *  a ring, for determinism. */
+function growBlob(grid, guarded, entry, cap, exists) {
+    const seen = new Set([key(guarded)]);
+    const blob = [];
+    let ring = RING_OFFSETS
+        .map(([dx, dy]) => ({ x: guarded.x + dx, y: guarded.y + dy, z: guarded.z }))
+        .filter(c => exists(c) && !seen.has(key(c)));
+    while (ring.length > 0 && blob.length < cap) {
+        ring.sort((a, b) => distanceMeters(a, entry) - distanceMeters(b, entry));
+        const nextRingSeed = [];
+        for (const c of ring) {
+            const k = key(c);
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            if (blob.length < cap)
+                blob.push(c);
+            nextRingSeed.push(c);
+        }
+        const nextSeen = new Set();
+        const next = [];
+        for (const c of nextRingSeed) {
+            for (const [dx, dy] of RING_OFFSETS) {
+                const n = { x: c.x + dx, y: c.y + dy, z: c.z };
+                const k = key(n);
+                if (exists(n) && !seen.has(k) && !nextSeen.has(k)) {
+                    nextSeen.add(k);
+                    next.push(n);
+                }
+            }
+        }
+        ring = next;
+    }
+    return blob;
+}
+//# sourceMappingURL=room-grid.js.map