@maka/maka-cli 5.391.0 → 5.392.0

package/bundle/typescript/src/commands/game/sideQuest/models/room.js

@@ -11,12 +11,26 @@ import * as fuzzyMatch from '../utilities/fuzzy-match.js';
 import { sameHostSide } from './player.js';
 import { AI } from '../../../../tools/ai/ai.class.js';
 import { AbstractRoom } from '../types/shared/abstracts.js';
-import { doorstepsOnto } from '../utilities/district-plane.js';
+import { doorstepsOnto, holesOf } from '../utilities/district-plane.js';
 import { dwellingDims } from '../utilities/dwellings.js';
 import { spotsActive, isPerchSpot, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
 import { canHearSpeech, canHearShout } from '../utilities/earshot.js';
 import { freshCrowd, clampHeadcount, deriveOccupancy } from '../utilities/crowd.js';
 import { synthesizeGrid, attachExitCell, detachExitCell, hashFnv1a, mulberry32, setCellBlocker, } from '../utilities/room-grid.js';
+/** An authored spot's cells, anchor first: `size` cells east and south
+ *  of `cell`, on the spot's level. */
+export function authoredSpotCells(s) {
+    if (!s.cell)
+        return undefined;
+    const w = Math.max(1, Math.round(s.size?.w ?? 1));
+    const h = Math.max(1, Math.round(s.size?.h ?? 1));
+    const z = s.level ?? 0;
+    const cells = [];
+    for (let dy = 0; dy < h; dy++)
+        for (let dx = 0; dx < w; dx++)
+            cells.push({ x: s.cell.x + dx, y: s.cell.y + dy, z });
+    return cells;
+}
 /**
  * A CAMERA'S DEVICE RATING when the scene does not say (p.356, which
  * lists "Camera" at 1 -- the same table that gives the door lock the 2
@@ -24,6 +38,13 @@ import { synthesizeGrid, attachExitCell, detachExitCell, hashFnv1a, mulberry32,
  * ordinary security devices at 2 and mil-spec at 4.
  */
 export const DEFAULT_CAMERA_RATING = 1;
+/**
+ * A WARD'S FORCE when a seed sets `warded` without one. Canon prices a
+ * ward by its Force and caps it nowhere in the ritual rules (p.296-298),
+ * so this is a house default for legacy seeds only -- the generator and
+ * the editor always write a Force (user ruling 2026-10-06).
+ */
+export const WARD_DEFAULT_FORCE = 4;
 export class Room extends AbstractRoom {
     logger = Logger.getInstance();
     actors = new Set();
@@ -38,6 +59,10 @@ export class Room extends AbstractRoom {
      *  utilities/outdoors.ts (the taxi curb and the generator's
      *  start-room guarantee both go through it). */
     outdoors;
+    /** The run's ground: the outdoor area under every other (seed `ground`). */
+    ground;
+    /** Storeys this room spans, from `storey` up (seed `storeys`); 1 unless tall. */
+    storeysSpanned = 1;
     isStartRoom;
     inventory = new Inventory();
     supportedLifestyles;
@@ -100,6 +125,12 @@ export class Room extends AbstractRoom {
      * to force either way per site.
      */
     camerasWireless;
+    /** THE LENSES AN AUTHOR HUNG (IRoomSeedJson.cameras): when set,
+     *  ensureCameras builds exactly these instead of deriving them. */
+    authoredCameras;
+    /** The room whose host these cameras are slaved to (surveillance.ts
+     *  cameraMasterHost). Unset = this room's own host, else the site's. */
+    camerasSlavedTo;
     /** Has this viewer pinned the cluster's icon? Inside the host these
      *  lenses are slaved to, there is nothing to pin: p.233 makes a
      *  persona in the WAN directly connected to everything on it, which is
@@ -292,6 +323,9 @@ export class Room extends AbstractRoom {
      *  authored plan, and by ensureGrid below for the room own extent. */
     reachable;
     footprint;
+    /** DOORS AND STAIRS WHERE THE AUTHOR PUT THEM (exit seed `cell`),
+     *  room-local, by the direction this room declared them. */
+    authoredDoorCells;
     storey;
     planeOverride;
     /**
@@ -468,6 +502,44 @@ export class Room extends AbstractRoom {
         }
         return bound;
     }
+    /**
+     * WHERE A STAIR STANDS IN AN AUTHORED ROOM (user 2026-10-06: "like doors
+     * n/s/e/w, doors u/d need to match their counterpart"). The two ends of a
+     * stair are over each other: this room's own word if it gave one, else
+     * the other end's spot carried across the storeys, else the middle of
+     * where the two floors overlap -- the same answer from both ends, so up
+     * here lands on down there. Room-local, kept inside the room.
+     */
+    stairCell(dir) {
+        const own = this.authoredDoorCells?.[dir];
+        if (own)
+            return own;
+        const fp = this.footprint;
+        const door = this.exits.get(dir);
+        const other = door instanceof Door ? door.getOtherSide(this) : undefined;
+        const ofp = other?.footprint;
+        if (!fp || !ofp)
+            return undefined;
+        const back = dir === Direction.UP ? Direction.DOWN : Direction.UP;
+        const theirs = other.authoredDoorCells?.[back];
+        let wx;
+        let wy;
+        if (theirs) {
+            wx = ofp.x + theirs.x;
+            wy = ofp.y + theirs.y;
+        }
+        else {
+            const x0 = Math.max(fp.x, ofp.x);
+            const x1 = Math.min(fp.x + fp.w, ofp.x + ofp.w);
+            const y0 = Math.max(fp.y, ofp.y);
+            const y1 = Math.min(fp.y + fp.h, ofp.y + ofp.h);
+            if (x1 <= x0 || y1 <= y0)
+                return undefined;
+            wx = Math.floor((x0 + x1 - 1) / 2);
+            wy = Math.floor((y0 + y1 - 1) / 2);
+        }
+        return { x: Math.max(0, Math.min(fp.w - 1, wx - fp.x)), y: Math.max(0, Math.min(fp.h - 1, wy - fp.y)) };
+    }
     ensureGrid() {
         // EVERY ROOM IS MATRIXED (player ruling 2026-08-25: "all rooms
         // should be a matrixed grid"). This used to return undefined for a
@@ -496,8 +568,14 @@ export class Room extends AbstractRoom {
             // A PACKED room that is one room of a building takes its doors
             // from the building layout the same way (Scene.partyDoorsFor), so
             // the gap in a shared wall is where both rooms stand their exit.
+            // ...and its STAIRS where the author put them (exit seed `cell`):
+            // up and down have no wall, so the room's own word is the cell.
             doorCells: this.footprint
-                ? this.scene?.ensurePlane().placements.get(this.name.trim().toLowerCase())?.doors
+                ? {
+                    ...(this.scene?.ensurePlane().placements.get(this.name.trim().toLowerCase())?.doors ?? {}),
+                    ...(this.stairCell(Direction.UP) ? { [Direction.UP]: this.stairCell(Direction.UP) } : {}),
+                    ...(this.stairCell(Direction.DOWN) ? { [Direction.DOWN]: this.stairCell(Direction.DOWN) } : {}),
+                }
                 : this.outdoors || this.roomType === 'host' ? undefined : this.scene?.partyDoorsFor?.(this.name),
             // NOTHING STANDS ON A DOORSTEP. A street holds no exit toward the
             // buildings that front it -- their doors are places, not
@@ -506,6 +584,12 @@ export class Room extends AbstractRoom {
             keepClear: this.outdoors && this.scene
                 ? doorstepsOnto(this.scene.ensurePlane(), this.name)
                 : undefined,
+            // ROOMS ALWAYS WIN (user 2026-10-06): an authored outdoor area loses
+            // the cells a building -- or, for the ground, a street -- drawn over
+            // it owns (district-plane.ts holesOf). A packed street has none.
+            holes: this.outdoors && this.footprint && this.scene
+                ? holesOf(this.scene.ensurePlane(), this.name)
+                : undefined,
             // AN OUTDOOR ROOM HAS NO EXTENT OF ITS OWN. It is a region of the
             // district plane, so it takes the cells the packer allotted it
             // and its size class is only what decided how wide the street was
@@ -540,6 +624,9 @@ export class Room extends AbstractRoom {
                 name: s.name, place: s.place, level: s.level, tags: s.tags,
                 preferPerimeter: doorwayKindOf(s.name) === 'lateral',
                 perch: isPerchSpot(s) || undefined,
+                // A perch's authored cell is the FLOOR cell under the lens (z 0);
+                // placePerches hangs it a storey up from there.
+                cells: isPerchSpot(s) && s.cell ? [{ x: s.cell.x, y: s.cell.y, z: 0 }] : authoredSpotCells(s),
             })),
             // DECLARED bindings only (seed `exits[].atSpot`), plus the
             // name-matched doorways, resolved below. The resolved exitSpot()
@@ -738,6 +825,13 @@ export class Room extends AbstractRoom {
      * saved.
      */
     warded = false;
+    /** The ward's Force (utilities/wards.ts); meaningful only while warded. */
+    wardForce = 0;
+    /** Who raised the ward -- passes it freely (p.315). */
+    wardCreator;
+    /** Structure boxes an astral attack has taken off the ward this
+     *  Combat Turn; refilled at the end of every turn (p.316). */
+    wardDamage = 0;
     // See IRoomConstructorConfig.watched (utilities/surveillance.ts).
     watched = false;
     /**
@@ -756,6 +850,23 @@ export class Room extends AbstractRoom {
     ensureCameras() {
         if (this._cameras.length > 0)
             return this._cameras;
+        // EXACTLY THE LENSES THE AUTHOR HUNG, where they hung them.
+        if (this.authoredCameras && this.roomType !== 'host') {
+            const taken = new Set((this.spots ?? []).map(s => s.name.toLowerCase()));
+            for (const cam of this.authoredCameras) {
+                let name = (cam.name?.trim() || `${cam.wall} camera`).toLowerCase();
+                for (let i = 2; taken.has(name); i++)
+                    name = `${cam.wall} camera ${i}`;
+                taken.add(name);
+                this._cameras.push(new Camera({ name, wall: cam.wall, rating: cam.rating ?? this.cameraRating, ...(cam.slavedTo ? { masterHost: cam.slavedTo } : {}), ...(cam.mountedOn ? { mountedOn: cam.mountedOn } : {}) }));
+                this.spots = [...(this.spots ?? []), {
+                        name, place: cam.wall, level: 1, tags: ['perch'],
+                        ...(cam.cell ? { cell: { x: cam.cell.x, y: cam.cell.y } } : {}),
+                    }];
+            }
+            this._grid = undefined;
+            return this._cameras;
+        }
         // A host's own sculpted space is the Matrix, not a floor with walls.
         if (!(this.watched || this.hasNode) || this.roomType === 'host')
             return this._cameras;
@@ -942,6 +1053,8 @@ export class Room extends AbstractRoom {
         this.description = config.description;
         this.roomType = config.roomType;
         this.outdoors = config.outdoors;
+        this.ground = config.ground === true ? true : undefined;
+        this.storeysSpanned = Math.max(1, Math.min(4, Math.floor(config.storeys ?? 1)));
         this.hasNode = config.hasNode ?? false;
         // THE MIGRATION, AT THE ONE DOOR EVERY ROOM COMES THROUGH.
         //
@@ -966,6 +1079,19 @@ export class Room extends AbstractRoom {
         if (this.host) {
             // Blank from a seed reads as "none declared", never as an empty line.
             this.host.purpose = Host.phrase(config.hostPurpose);
+            // A NAMED HOST: its own label, and its Matrix-side room wears it.
+            // THE LINEUP, as the author ordered it (ic.ts resolveICOrder drops
+            // names the engine does not model; the authored audit faults them).
+            if (config.icOrder && config.icOrder.length > 0)
+                this.host.icOrder = [...config.icOrder];
+            if (config.icBricked)
+                this.host.icBricked = config.icBricked;
+            const named = Host.phrase(config.hostName);
+            if (named) {
+                this.host.displayName = named;
+                if (this.host.room && this.host.room !== this)
+                    this.host.room.name = named;
+            }
             this.host.sculpt = Host.phrase(config.hostSculpt);
             // A seeded quality implies the invitation; a bare `hostInvite`
             // is open to everyone who can see the host.
@@ -974,7 +1100,15 @@ export class Room extends AbstractRoom {
             }
         }
         this.warded = config.warded ?? false;
+        this.wardForce = this.warded ? Math.max(1, Math.floor(config.wardForce ?? WARD_DEFAULT_FORCE)) : 0;
+        this.wardCreator = this.warded ? config.wardCreator || undefined : undefined;
         this.watched = config.watched ?? false;
+        this.authoredCameras = config.cameras && config.cameras.length > 0 ? config.cameras : undefined;
+        if (this.authoredCameras)
+            this.watched = true;
+        if (config.camerasWireless !== undefined)
+            this.camerasWireless = config.camerasWireless;
+        this.camerasSlavedTo = config.camerasSlavedTo;
         this.exits = config.exits || new Map();
         this.inventory = config.inventory || new Inventory();
         this.isStartRoom = config.isStartRoom || false;
@@ -1292,7 +1426,11 @@ Keep it concise and dramatic.`;
          * runtime-attached hideout, keep the symmetric wiring they have
          * always had.
          */
-        const streetDoor = this.footprint !== undefined && isOutdoorsPlace(targetRoom) && !isOutdoorsPlace(this);
+        // A SIDE DOOR only: a stair up onto a roof or down into a yard is one
+        // flight with two ends, filed in both rooms like any other (user
+        // 2026-10-06: "doors u/d need to match their counterpart").
+        const lateral = direction !== Direction.UP && direction !== Direction.DOWN;
+        const streetDoor = lateral && this.footprint !== undefined && isOutdoorsPlace(targetRoom) && !isOutdoorsPlace(this);
         if (streetDoor) {
             // No dedupe either: a building may open onto the same street
             // twice (a front door and a side door), and each is its own Door.

package/bundle/typescript/src/commands/game/sideQuest/models/scene.js

@@ -1942,12 +1942,15 @@ export class Scene extends AbstractScene {
             name: r.name,
             size: r.size,
             outdoors: r.outdoors,
+            ground: r.ground,
+            storeys: r.storeysSpanned > 1 ? r.storeysSpanned : undefined,
             exits: [...r.exits.entries()].map(([direction, exit]) => ({
                 direction,
                 targetRoom: exit instanceof Door ? exit.getOtherSide(r).name : String(exit),
             })),
             footprint: r.footprint,
             storey: r.storey,
+            doorAt: r.footprint ? r.authoredDoorCells : undefined,
             // A DWELLING BRINGS ITS OWN FLOOR (utilities/dwellings.ts), so the
             // square the plane parks is the square the room grid builds.
             dims: r.dwelling !== undefined ? dwellingDims(r.dwelling) : undefined,

package/bundle/typescript/src/commands/game/sideQuest/utilities/affordances.js

@@ -13,13 +13,6 @@ export const AFFORDANCE_FLAVOR = {
         failureMessage: `Your intrusion trips a countermeasure -- the system logs the attempt and pings whoever's watching.`,
         hint: `This looks hackable -- try "hack" to skip finding the code (Logic + hacking). Fail, and the system pings whoever's watching.`,
     },
-    ward: {
-        verb: 'cast',
-        verbs: ['cast', 'dispel'],
-        resists: `Your hands find nothing to work and your tools find nothing to bite -- the barrier isn't matter. It answers to the Art: "cast" at it, or "dispel" it.`,
-        failureMessage: `The weave slips through your fingers -- backlash crackles outward, and something out there felt it.`,
-        hint: `This could be unwoven magically -- try "dispel" (Magic + counterspelling) or "cast" (the casting pool). Fail, and the backlash BITES.`,
-    },
     person: {
         verb: 'bluff',
         verbs: ['bluff', 'persuade', 'subdue'],
@@ -35,7 +28,9 @@ export function verbsFor(kind) {
 }
 /** WARD-SOUNDING NAMES, checked first: a magical barrier is rare and
  *  specific enough here that missing one costs less than a false
- *  positive stealing a genuine lock from `lock`. */
+ *  positive stealing a genuine lock from `lock`. A ward is not a device
+ *  any more -- it is a room's astral barrier (utilities/wards.ts) -- so a
+ *  device that reads as one is moved onto its room (isWardDevice). */
 const WARD_HINTS = ['ward', 'seal', 'rune', 'glyph', 'weave', 'astral', 'spell', 'enchant', 'mystic'];
 /** PHYSICAL-MECHANISM NAMES, checked second -- the actual fix
  *  (backlog 2uNPnc4L6jHaYEtnN / tuku6Z5XTtmNemkzd, 2026-09-08). A
@@ -64,13 +59,25 @@ const LOCK_HINTS = [
  * description first.
  */
 export function clampDeviceKind(rawKind, name, description) {
-    if (rawKind === 'lock' || rawKind === 'panel' || rawKind === 'ward')
+    if (rawKind === 'lock' || rawKind === 'panel')
         return rawKind;
     const text = `${name} ${description ?? ''}`.toLowerCase();
-    if (WARD_HINTS.some(hint => text.includes(hint)))
-        return 'ward';
     if (LOCK_HINTS.some(hint => text.includes(hint)))
         return 'lock';
     return 'panel';
 }
+/**
+ * IS THIS "DEVICE" REALLY A WARD (user 2026-10-06)? The retired kind, or
+ * an unknown kind whose name or description reads as one. Callers move
+ * it onto its room as an astral barrier (seed-migration.ts
+ * wardDevicesToRooms) instead of clamping it into a lock or a panel.
+ */
+export function isWardDevice(rawKind, name, description) {
+    if (rawKind === 'ward')
+        return true;
+    if (rawKind === 'lock' || rawKind === 'panel')
+        return false;
+    const text = `${name} ${description ?? ''}`.toLowerCase();
+    return WARD_HINTS.some(hint => text.includes(hint));
+}
 //# sourceMappingURL=affordances.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/alarmed-staff.js

@@ -62,6 +62,9 @@ export function alarmedStaff(scene, player) {
         // Ice is not staff: a program answers to the host's dice
         // (utilities/ic.ts), never to an alarm beat (NPC.isConstruct).
         .filter(npc => !npc.isConstruct())
+        // Nor a spider's slumped body: the person is in the host
+        // (utilities/spider.ts), and the host's fight is how they answer.
+        .filter(npc => npc.plane === 'meat')
         .filter(npc => !npc.isIncapacitated());
 }
 /**

package/bundle/typescript/src/commands/game/sideQuest/utilities/ar.js

@@ -589,8 +589,10 @@ export function astralTags(scene, actor, room) {
             // A ward is opaque astrally (SG p.107) -- the one thing that
             // stops an aura. Cast over a PLACE, so it is the rooms that
             // carry it, never the cells between.
-            const wards = (other.warded ? 1 : 0)
-                + (room.warded && other !== room ? 1 : 0);
+            // A ward is a SURFACE: it hides what is on its far side, never
+            // what shares the room with you (a body in your own warded room
+            // was going dark because its room was warded).
+            const wards = other === room ? 0 : (other.warded ? 1 : 0) + (room.warded ? 1 : 0);
             if (!auraVisible(d, wards))
                 continue;
             if (!castsAura(body))

package/bundle/typescript/src/commands/game/sideQuest/utilities/astral-move.js

@@ -4,6 +4,7 @@ import { isOutdoorsPlace } from './outdoors.js';
 import { astralStepFrom, spotForCell } from './spots.js';
 import { isOpenGround, isOpenAir } from './district-plane.js';
 import { hint } from './hints.js';
+import { spendWardPass, wardHolds } from './wards.js';
 import { METERS_PER_CELL } from './room-grid.js';
 /**
  * THE OUTDOOR ROOM A PATCH OF UNOWNED GROUND BELONGS TO.
@@ -75,7 +76,7 @@ export function driftAstral(scene, actor, rooms, direction, count, untilOut = fa
     // the room it is trying to leave is large.
     const limit = untilOut ? 50 : count;
     while (taken < limit) {
-        const step = astralStepFrom(plane, cell, direction, 1, byKey, c => scene.barrierAt?.(c, 'mana', actor.name)?.barrier.caster);
+        const step = astralStepFrom(plane, cell, direction, 1, byKey, c => scene.barrierAt?.(c, 'mana', actor.name)?.barrier.caster, r => wardHolds(r, actor));
         if (step.taken === 0) {
             blockedBy = step.blockedBy;
             ward = step.ward;
@@ -178,6 +179,10 @@ export function driftAstral(scene, actor, rooms, direction, count, untilOut = fa
     }
     scene.updateStatus?.();
     scene.updateExits?.(actor.currentLocation);
+    // A PRESSED-THROUGH WARD IS ONE CROSSING (wards.ts): the drift that
+    // made it spends the pass, so the way back out is pressed again.
+    if (taken > 0)
+        spendWardPass(actor);
     return { cell, taken, arrived, blockedBy, ward, metres: taken * METERS_PER_CELL };
 }
 /** What stopped you, said the way the astral would say it. */
@@ -197,7 +202,7 @@ export function driftRefusal(d, direction) {
         return `A mana barrier hangs across the way ${direction}${d.ward ? ` -- ${d.ward}'s working` : ''}: a hazy, solid sheet of woven mana. The astral does not pass (p.315-316).`;
     }
     if (d.blockedBy === 'ward') {
-        return `A lattice of woven mana stands across the way ${direction}${d.ward ? ` -- ${d.ward}'s` : ''}. The astral does not pass.`;
+        return `A ward stands across the way ${direction}${d.ward ? ` -- the one over ${d.ward}` : ''}: a hazy, solid lattice of woven mana. The astral does not pass${hint(` -- "go ${direction}" presses through it (Magic + Charisma v. its Force x 2, p.316), "attack ward" tears at it`)}.`;
     }
     // WHICH NOTHING IT IS depends on which way you tried. Downward the
     // refusal is canon and worth saying out loud -- solid earth is the

package/bundle/typescript/src/commands/game/sideQuest/utilities/barrier-combat.js

@@ -7,7 +7,7 @@ export function resolveBarrierStrike(scene, logger, attacker, device, room, opts
     const meta = [];
     const done = (opened = false) => ({ world, meta, opened });
     if (device.structure <= 0) {
-        world.push(`${device.name} isn't matter -- there is nothing for a round to hit. It answers to the Art.`);
+        world.push(`${device.name} has no Structure -- there is nothing for a round to break.`);
         return done();
     }
     if (device.isOpen() || device.isHoled) {

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-turn.js

@@ -1,3 +1,4 @@
+import { mendWards } from './wards.js';
 import { regenerate } from './barrier-geometry.js';
 import { rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP, rollPool, formatRoll } from './dice.js';
 import { ActionBudget } from './action-budget.js';
@@ -823,6 +824,14 @@ export class CombatEncounter {
             mended = true;
             this.logger.log(`{cyan-fg}${barrier.caster}'s ${kind === 'mana' ? 'mana barrier' : 'barrier'} knits itself whole again -- Structure ${barrier.structure} (${kind === 'mana' ? 'p.316' : 'p.294'}).{/cyan-fg}`, { room: barrier.roomName });
         }
+        // WARDS TOO (p.316): a ward is a mana barrier, whole again at the end
+        // of every Combat Turn -- tearing one down is a single turn's work.
+        if (kind === 'mana') {
+            for (const ward of mendWards(Object.values(this.scene.getRooms?.() ?? {}))) {
+                mended = true;
+                this.logger.log(`{cyan-fg}The ward over ${ward.name} knits itself whole again -- Structure ${ward.wardForce} (p.316).{/cyan-fg}`, { room: ward.name });
+            }
+        }
         if (mended) {
             this.scene.updateStatus?.();
             this.scene.updateExits?.(this.room);

package/bundle/typescript/src/commands/game/sideQuest/utilities/district-plane.js

@@ -626,7 +626,8 @@ export function planeFaults(plane, rooms) {
         for (let j = i + 1; j < floors.length; j++) {
             const [an, a] = floors[i];
             const [bn, b] = floors[j];
-            if (a.origin.z !== b.origin.z)
+            // Spans that share a storey (a tall room reaches up through them).
+            if (a.origin.z + (a.height ?? 1) <= b.origin.z || b.origin.z + (b.height ?? 1) <= a.origin.z)
                 continue;
             if (overlaps(a, b.origin.x - WALL_CELLS, b.origin.y - WALL_CELLS, b.dims.x + 2 * WALL_CELLS, b.dims.y + 2 * WALL_CELLS)) {
                 out.push(`${label(an)} and ${label(bn)} are drawn touching, with no wall between them.`);
@@ -991,9 +992,11 @@ function interiorMap(placements) {
     for (const [name, at] of placements) {
         if (at.outdoors)
             continue;
-        for (let x = at.origin.x; x < at.origin.x + at.dims.x; x++) {
-            for (let y = at.origin.y; y < at.origin.y + at.dims.y; y++) {
-                interiorAt.set(`${x},${y},${at.origin.z}`, name);
+        for (let z = at.origin.z; z < at.origin.z + (at.height ?? 1); z++) {
+            for (let x = at.origin.x; x < at.origin.x + at.dims.x; x++) {
+                for (let y = at.origin.y; y < at.origin.y + at.dims.y; y++) {
+                    interiorAt.set(`${x},${y},${z}`, name);
+                }
             }
         }
     }
@@ -1046,20 +1049,21 @@ function ringsAndDoorways(placements, graph) {
     for (const [, at] of placements) {
         if (at.outdoors)
             continue;
-        const z = at.origin.z;
-        for (let x = at.origin.x - WALL_CELLS; x < at.origin.x + at.dims.x + WALL_CELLS; x++) {
-            for (let y = at.origin.y - WALL_CELLS; y < at.origin.y + at.dims.y + WALL_CELLS; y++) {
-                const inside = x >= at.origin.x && x < at.origin.x + at.dims.x
-                    && y >= at.origin.y && y < at.origin.y + at.dims.y;
-                if (inside)
-                    continue;
-                // Never wall over someone else's floor: two buildings sharing a
-                // gutter get one wall between them, not two overlapping rings.
-                if (interiorAt.has(`${x},${y},${z}`))
-                    continue;
-                walls.add(`${x},${y},${z}`);
+        // A TALL ROOM IS WALLED ON EVERY STOREY IT SPANS (seed `storeys`).
+        for (let z = at.origin.z; z < at.origin.z + (at.height ?? 1); z++)
+            for (let x = at.origin.x - WALL_CELLS; x < at.origin.x + at.dims.x + WALL_CELLS; x++) {
+                for (let y = at.origin.y - WALL_CELLS; y < at.origin.y + at.dims.y + WALL_CELLS; y++) {
+                    const inside = x >= at.origin.x && x < at.origin.x + at.dims.x
+                        && y >= at.origin.y && y < at.origin.y + at.dims.y;
+                    if (inside)
+                        continue;
+                    // Never wall over someone else's floor: two buildings sharing a
+                    // gutter get one wall between them, not two overlapping rings.
+                    if (interiorAt.has(`${x},${y},${z}`))
+                        continue;
+                    walls.add(`${x},${y},${z}`);
+                }
             }
-        }
     }
     // DOORWAYS: a gap in the wall between two rooms the exit graph joins
     // laterally. Punched on the facing edge, nearest the neighbour, so
@@ -1124,7 +1128,27 @@ function overlaps(a, bx, by, bw, bh) {
  * Room.ensureGrid takes its exit cell FROM the plane (the reverse of
  * the packed path). One rule, no jitter, nothing to reconcile.
  */
-function authoredDoors(placements, graph) {
+function authoredDoors(placements, graph, rooms = []) {
+    // WHERE AN AUTHOR MOVED A DOOR (user 2026-10-06: "move ... the door
+    // placement, within reason based on wall area between the rooms"):
+    // one plane coordinate along the shared wall per pair of rooms, from
+    // whichever side declared it, so both halves of the door agree and it
+    // stays one gap in one wall (planeFaults). Clamped below to the
+    // overlap -- a door cannot open onto masonry.
+    const pairKey = (a, b) => [a, b].sort().join('|');
+    const along = new Map();
+    for (const room of rooms) {
+        const at = placements.get(norm(room.name));
+        if (!at || !room.doorAt)
+            continue;
+        for (const link of graph.get(norm(room.name)) ?? []) {
+            const lat = LATERAL[link.direction];
+            const cell = room.doorAt[link.direction];
+            if (!lat || !cell)
+                continue;
+            along.set(pairKey(norm(room.name), link.to), lat[0] !== 0 ? at.origin.y + cell.y : at.origin.x + cell.x);
+        }
+    }
     for (const [name, at] of placements) {
         if (at.outdoors)
             continue;
@@ -1138,13 +1162,19 @@ function authoredDoors(placements, graph) {
                 // East/west wall: the door slides along Y.
                 const lo = Math.max(at.origin.y, other.origin.y);
                 const hi = Math.min(at.origin.y + at.dims.y, other.origin.y + other.dims.y);
-                const midY = hi > lo ? Math.floor((lo + hi - 1) / 2) : at.origin.y + Math.floor(at.dims.y / 2);
+                const authored = along.get(pairKey(name, link.to));
+                const midY = hi > lo
+                    ? (authored !== undefined ? clamp(authored, lo, hi - 1) : Math.floor((lo + hi - 1) / 2))
+                    : at.origin.y + Math.floor(at.dims.y / 2);
                 doors[link.direction] = { x: 0, y: clamp(midY - at.origin.y, 0, at.dims.y - 1) };
             }
             else {
                 const lo = Math.max(at.origin.x, other.origin.x);
                 const hi = Math.min(at.origin.x + at.dims.x, other.origin.x + other.dims.x);
-                const midX = hi > lo ? Math.floor((lo + hi - 1) / 2) : at.origin.x + Math.floor(at.dims.x / 2);
+                const authored = along.get(pairKey(name, link.to));
+                const midX = hi > lo
+                    ? (authored !== undefined ? clamp(authored, lo, hi - 1) : Math.floor((lo + hi - 1) / 2))
+                    : at.origin.x + Math.floor(at.dims.x / 2);
                 doors[link.direction] = { x: clamp(midX - at.origin.x, 0, at.dims.x - 1), y: 0 };
             }
         }
@@ -1168,6 +1198,10 @@ function parkUnplaced(rooms, placements, graph, byName, notes) {
         for (const at of placements.values()) {
             if (at.origin.z !== z)
                 continue;
+            // THE GROUND IS WHERE THINGS PARK, not in their way: a room set
+            // down on it cuts its own hole (roomAtCell).
+            if (at.ground)
+                continue;
             // One clear cell all round, so two rings never fuse.
             if (overlaps(at, x - 1, y - 1, w + 2, h + 2))
                 return false;
@@ -1258,11 +1292,13 @@ export function buildAuthoredPlane(rooms) {
             origin: { x: fp.x, y: fp.y, z: room.storey ?? 0 },
             dims: { x: Math.max(1, fp.w), y: Math.max(1, fp.h) },
             outdoors: room.outdoors === true,
+            ...(room.ground ? { ground: true } : {}),
+            ...(room.storeys && room.storeys > 1 ? { height: room.storeys } : {}),
         });
     }
     parkUnplaced(rooms, placements, graph, byName, notes);
-    authoredDoors(placements, graph);
-    const storeys = [...new Set([0, ...[...placements.values()].map(p => p.origin.z)])]
+    authoredDoors(placements, graph, rooms);
+    const storeys = [...new Set([0, ...[...placements.values()].flatMap(p => Array.from({ length: p.height ?? 1 }, (_, i) => p.origin.z + i))])]
         .sort((a, b) => a - b);
     // The canvas is the extent worth DRAWING, not a fence -- the edges
     // are open, so this only has to cover what exists.
@@ -1305,16 +1341,34 @@ export function worldCell(plane, room, local) {
         return undefined;
     return { x: at.origin.x + local.x, y: at.origin.y + local.y, z: at.origin.z + local.z };
 }
-/** Which room owns a plane cell, if any. */
+/**
+ * Which room owns a plane cell, if any.
+ *
+ * ROOMS ALWAYS WIN (user rulings 2026-10-06): where rectangles overlap,
+ * an indoor room owns the cell; else an outdoor space; the ground --
+ * the area under everything -- only what nothing else covers. So a
+ * building drawn on a street cuts its floor out of the street, and a
+ * street drawn on the ground cuts its own out of the ground, whatever
+ * order they were drawn or named in. A packed district never overlaps,
+ * so it answers exactly as the first-match scan always did.
+ */
 export function roomAtCell(plane, c) {
+    let space;
+    let ground;
     for (const [name, at] of plane.placements) {
-        if (at.origin.z !== c.z)
+        if (c.z < at.origin.z || c.z >= at.origin.z + (at.height ?? 1))
+            continue;
+        if (c.x < at.origin.x || c.x >= at.origin.x + at.dims.x
+            || c.y < at.origin.y || c.y >= at.origin.y + at.dims.y)
             continue;
-        if (c.x >= at.origin.x && c.x < at.origin.x + at.dims.x
-            && c.y >= at.origin.y && c.y < at.origin.y + at.dims.y)
+        if (!at.outdoors)
             return name;
+        if (at.ground)
+            ground ??= name;
+        else
+            space ??= name;
     }
-    return undefined;
+    return space ?? ground;
 }
 /**
  * Straight-line distance between two plane cells, in metres. The whole
@@ -1650,6 +1704,30 @@ export const planeSeed = hashFnv1a;
  * side is the ground outside it. No side arithmetic and no exit graph:
  * ask which of a doorway's four neighbours this street covers.
  */
+/**
+ * THE CELLS OF AN OUTDOOR AREA'S RECTANGLE IT DOES NOT OWN, room-local
+ * "x,y" (user rulings 2026-10-06: "rooms always win"; spaces are drawn
+ * over the ground): another room's floor or a wall. Empty for anything
+ * indoor, and for an area nothing is drawn over -- which is every packed
+ * district, so their grids are untouched.
+ */
+export function holesOf(plane, room) {
+    const holes = new Set();
+    const me = norm(room);
+    const at = plane.placements.get(me);
+    if (!at?.outdoors)
+        return holes;
+    const z = at.origin.z;
+    for (let lx = 0; lx < at.dims.x; lx++) {
+        for (let ly = 0; ly < at.dims.y; ly++) {
+            const x = at.origin.x + lx;
+            const y = at.origin.y + ly;
+            if (plane.walls.has(`${x},${y},${z}`) || roomAtCell(plane, { x, y, z }) !== me)
+                holes.add(`${lx},${ly}`);
+        }
+    }
+    return holes;
+}
 export function doorstepsOnto(plane, room) {
     const at = plane.placements.get(norm(room));
     if (at === undefined || !at.outdoors)
@@ -1667,6 +1745,10 @@ export function doorstepsOnto(plane, room) {
                 continue;
             if (y < at.origin.y || y >= at.origin.y + at.dims.y)
                 continue;
+            // Only the street's OWN ground: a building drawn inside it owns
+            // the cells on its side of the doorway (roomAtCell).
+            if (roomAtCell(plane, { x, y, z: at.origin.z }) !== norm(room))
+                continue;
             const local = `${x - at.origin.x},${y - at.origin.y}`;
             if (seen.has(local))
                 continue;