@dreadwood-types/types 0.1.49 → 0.1.51

package/dist/constants.js

@@ -63,14 +63,36 @@ export const PLAYABLE_CHUNKS_X = FARMLAND_CHUNKS_X + VILLAGE_CHUNKS_X + EASTLAND
 export const PLAYABLE_CHUNKS_Z = 3;
 export const FARMLAND_WIDTH = CHUNK_SIZE * FARMLAND_CHUNKS_X;
 export const WORLD_EAST_CHUNKS = 2;
-export const WORLD_NORTH_CHUNKS = 23;
+/**
+ * The northern extension (James, 2026-09-25: "extend the map north a bit"
+ * for the Frozen Shore and its polar bears): two chunks of new rows above the
+ * old north edge. Every surface place moved south by NORTH_SHIFT rows with
+ * it, pad-relative ones through WORLD_NORTH_PAD and the hand-written world z
+ * values by +NORTH_SHIFT in place; the underground strip (x >=
+ * UNDERGROUND_ORIGIN_X) did not move. Coordinate hashes read `legacyZ` so the
+ * scatter stayed where it was, and saved characters are moved once, at the
+ * backend's boot (db/characters.ts, WORLD_REVISION). Proved with the
+ * backend's scripts/world-fingerprint.ts and world-shift-diff.ts.
+ */
+export const WORLD_NORTH_EXTENSION_CHUNKS = 2;
+export const NORTH_SHIFT = CHUNK_SIZE * WORLD_NORTH_EXTENSION_CHUNKS;
+export const WORLD_NORTH_CHUNKS = 23 + WORLD_NORTH_EXTENSION_CHUNKS;
+/**
+ * The world's layout revision, saved on each character: 1 is the 64-row
+ * northern extension. A character saved before it (no revision) is moved
+ * NORTH_SHIFT rows south once, when the backend boots, if it was on the
+ * surface.
+ */
+export const WORLD_REVISION = 1;
 /**
  * Open sea south of the playable strip. Padding the far side of the beach,
  * not the near side, so every existing world coordinate is untouched - only
  * WORLD_HEIGHT grows. It exists so the Long Pier has somewhere to go: the
  * playable ocean is fourteen rows deep, which is a jetty, not a pier.
+ * Five since 2026-09-24, when the pier stretched to 130 rows: the ship loop
+ * (SeaTraffic) needs its offshore leg past the pier head's clearance.
  */
-export const WORLD_SOUTH_CHUNKS = 4;
+export const WORLD_SOUTH_CHUNKS = 5;
 export const DEMO_CHUNKS_X = PLAYABLE_CHUNKS_X + WORLD_EAST_CHUNKS;
 export const DEMO_CHUNKS_Z = PLAYABLE_CHUNKS_Z + WORLD_NORTH_CHUNKS + WORLD_SOUTH_CHUNKS;
 export const PLAYABLE_WIDTH = CHUNK_SIZE * PLAYABLE_CHUNKS_X;
@@ -93,6 +115,14 @@ export const GRID_CHUNKS_X = DEMO_CHUNKS_X + UNDERGROUND_CHUNKS_X;
 export const GRID_CHUNKS_Z = DEMO_CHUNKS_Z;
 export const GRID_WIDTH = CHUNK_SIZE * GRID_CHUNKS_X;
 export const GRID_HEIGHT = CHUNK_SIZE * GRID_CHUNKS_Z;
+/**
+ * The z a coordinate hash should read: the tile's z from before the northern
+ * extension, so scatter, noise and per-tile variety landed where they always
+ * had. The underground strip never moved, so its z is its own.
+ */
+export function legacyZ(x, z) {
+    return x < UNDERGROUND_ORIGIN_X ? z - NORTH_SHIFT : z;
+}
 /**
  * Kinds that never carry an Identify marker, because nothing happens when you
  * click them.
@@ -149,8 +179,11 @@ export const NON_IDENTIFIABLE_KINDS = new Set([
     'stalagmite',
     'icecrystal',
     'iceshard',
+    'icefloe',
     'dreadprop',
     'depthsprop',
+    'frozenchest',
+    'charcoalmound',
     'icefall',
     'icearch',
     'icecell',
@@ -363,6 +396,10 @@ export function entityBlocksWalk(kind) {
         // The Depths' dressing is solid unless the style says floor (grates,
         // sigils, spills, lanterns hung from the dark); see visitBlockedWalkOffsets.
         kind === 'depthsprop' ||
+        // The Frozen Chest is an iron-bound box you open, not walk over.
+        kind === 'frozenchest' ||
+        // A charcoal mound is a heap of earth over smouldering logs.
+        kind === 'charcoalmound' ||
         // A table of fish and knives is furniture, not floor.
         kind === 'baittable' ||
         // The keep is a building you cannot enter yet; a plinth and a basin are solid.
@@ -382,6 +419,8 @@ export function entityBlocksWalk(kind) {
         kind === 'gardenwall' ||
         kind === 'banner' ||
         kind === 'yardprop' ||
+        // The Blender buildings: a hollow ring or solid, by model (CAPITAL_BUILDING_MODELS).
+        kind === 'capitalbuilding' ||
         // Crystals and pillars are solid; a gate bars its whole span and a rune
         // arch its two piers (see visitBlockedWalkOffsets). Frost traps and rope
         // bridges are floor you walk over.
@@ -704,6 +743,9 @@ export function buildingFloorSurface(kind, style) {
         return SurfaceType.Boards;
     if (kind === 'temple' || kind === 'forgehall' || kind === 'manor' || kind === 'castle')
         return SurfaceType.Flagstones;
+    // The Blender halls (the Grand Exchange, the Main Forge) stand on flags.
+    if (kind === 'capitalbuilding')
+        return SurfaceType.Flagstones;
     return SurfaceType.Path;
 }
 /**
@@ -777,6 +819,68 @@ export function rowhouseTokens(style) {
     const parts = (style ?? '').split('-');
     return new Set(parts.slice(1, Math.max(1, parts.length - 1)));
 }
+export const CAPITAL_BUILDING_MODELS = {
+    // v003 (capital-workshop/scripts/grandexchange_v003.py): 19 x 13, door S.
+    // Porch columns at x +-2.15 and the small planters at x +-4.7 stand one
+    // row out (dz 7); the tree planters at x +-9.8 too; the lamp posts at x
+    // +-3.4 and the notice boards at x +-6.6 two rows out (dz 8).
+    grandexchange: {
+        across: 19,
+        deep: 13,
+        mouth: 1,
+        frontProps: [[-2, 7], [2, 7], [-5, 7], [5, 7], [-10, 7], [10, 7], [-3, 8], [3, 8], [-7, 8], [7, 8]],
+    },
+    mainforge: { across: 17, deep: 13, mouth: 5 },
+    smelter: { across: 7, deep: 7, mouth: 0, solid: true },
+    // The King's Statue v003 is 5 across (its cypresses and flower beds flank the
+    // plinth, as the Noble sheet draws it) and 3 deep; its plan rows reserve 5x5.
+    kingstatue: { across: 5, deep: 3, mouth: 0, solid: true },
+    keeplion: { across: 3, deep: 3, mouth: 0, solid: true },
+    victorystatue: { across: 5, deep: 5, mouth: 0, solid: true },
+};
+/** The model id in a `capitalbuilding` style (its first dash token), when it names one. */
+export function capitalBuildingModelId(style) {
+    const id = (style ?? '').split('-')[0] ?? '';
+    return Object.prototype.hasOwnProperty.call(CAPITAL_BUILDING_MODELS, id) ? id : null;
+}
+export function capitalBuildingModel(style) {
+    const id = capitalBuildingModelId(style);
+    return id ? CAPITAL_BUILDING_MODELS[id] : null;
+}
+/**
+ * A local-frame offset (door on +Z) turned to the building's facing: the
+ * same turn the assets make (`facingYaw`) and visitFurnitureTiles applies.
+ */
+export function turnBuildingOffset(lx, lz, facing) {
+    if (facing === 'negZ')
+        return [-lx, -lz];
+    if (facing === 'posX')
+        return [lz, -lx];
+    if (facing === 'negX')
+        return [-lz, lx];
+    return [lx, lz];
+}
+/**
+ * THE MOUTH RULE (2026-09-25). How many tiles either side of the door's
+ * middle tile are open on the door side: 2 for a `mouth5` style token, 1 for
+ * `mouth3`, 3 for `mouth7` (any odd `mouthN`), else the Blender model's own
+ * mouth, else 0 (a one-tile door). The collision (visitBlockedWalkOffsets,
+ * so the server and the client's prediction) and the roof hiding
+ * (isBuildingInteriorOffset) both take it, so the three always agree.
+ */
+export function buildingDoorHalfWidth(kind, style) {
+    for (const token of (style ?? '').split('-')) {
+        const m = /^mouth(\d+)$/.exec(token);
+        if (m)
+            return Math.max(0, Math.floor((Number(m[1]) - 1) / 2));
+    }
+    if (kind === 'capitalbuilding') {
+        const model = capitalBuildingModel(style);
+        if (model && model.mouth > 1)
+            return Math.floor((model.mouth - 1) / 2);
+    }
+    return 0;
+}
 /**
  * citywall: the piece stands on the wall's outer row and is two tiles thick
  * inward (n: +z is inward, s: -z, w: +x, e: -x). A bastion is a 3x3 drum on
@@ -822,19 +926,43 @@ export const GATEHOUSE_SIDE_HALF_SPAN = 4;
 export const GATEHOUSE_HALF_DEPTH = 3;
 export const GATEHOUSE_SIDE_HALF_DEPTH = 2;
 export const GATEHOUSE_PASSAGE_HALF_W = 2;
+/**
+ * A gatehouse's facing: the LAST n/s/e/w token of its style (`main-w`,
+ * `side-e`, `main-shut-n`). The facing is always written last, because the
+ * frontend turns the model by the style's last token.
+ */
+export function gatehouseFacing(style) {
+    const tokens = (style ?? 'main-w').split('-');
+    for (let i = tokens.length - 1; i >= 0; i--) {
+        const t = tokens[i];
+        if (t === 'n' || t === 's' || t === 'e' || t === 'w')
+            return t;
+    }
+    return 'w';
+}
+/**
+ * A barred gatehouse (2026-09-25, the Capital's North and South Gates):
+ * a `shut` token (`main-shut-n`) lets the portcullis down, and the passage
+ * blocks like the towers, so the collision alone keeps it shut whatever the
+ * builder does with the wall rows under it.
+ */
+export function isGatehouseShut(style) {
+    return (style ?? '').split('-').includes('shut');
+}
 /** Which way the passage runs: -w/-e styles run along x, -n/-s along z. */
 export function gatehousePassageAlongX(style) {
-    const facing = (style ?? 'main-w').split('-').pop();
+    const facing = gatehouseFacing(style);
     return facing === 'w' || facing === 'e';
 }
 export function visitGatehouseOffsets(style, visit) {
     const alongX = gatehousePassageAlongX(style);
     const main = (style ?? 'main-w').startsWith('main');
+    const shut = isGatehouseShut(style);
     const span = main ? GATEHOUSE_HALF_SPAN : GATEHOUSE_SIDE_HALF_SPAN;
     const depth = main ? GATEHOUSE_HALF_DEPTH : GATEHOUSE_SIDE_HALF_DEPTH;
     for (let along = -depth; along <= depth; along++) {
         for (let across = -span; across <= span; across++) {
-            if (Math.abs(across) <= GATEHOUSE_PASSAGE_HALF_W)
+            if (!shut && Math.abs(across) <= GATEHOUSE_PASSAGE_HALF_W)
                 continue;
             if (alongX)
                 visit(along, across);
@@ -849,6 +977,17 @@ export function buildingFootprintExtents(kind, scale, style) {
     }
     if (kind === 'castle')
         return { radiusX: CASTLE_KEEP_HALF_X, radiusZ: CASTLE_KEEP_HALF_Z };
+    if (kind === 'capitalbuilding') {
+        const model = capitalBuildingModel(style);
+        if (!model)
+            return { radiusX: 0, radiusZ: 0 };
+        const across = Math.floor((model.across - 1) / 2);
+        const deep = Math.floor((model.deep - 1) / 2);
+        const facing = stoneHouseDoorFacing(style);
+        if (facing === 'posX' || facing === 'negX')
+            return { radiusX: deep, radiusZ: across };
+        return { radiusX: across, radiusZ: deep };
+    }
     if (kind === 'stonehouse') {
         const variant = stoneHouseVariant(style);
         if (variant === 'lodge') {
@@ -902,19 +1041,26 @@ export function buildingFootprintRadius(kind, scale, style) {
     const { radiusX, radiusZ } = buildingFootprintExtents(kind, scale, style);
     return Math.max(radiusX, radiusZ);
 }
-export function isBuildingDoorOffset(dx, dz, footprint, doorFacing = 'posZ') {
+/**
+ * The door opening on a building's ring. `halfW` is the mouth rule's
+ * half-width (buildingDoorHalfWidth): 0 is the one middle tile, 2 a
+ * five-wide mouth. The corners always stay wall.
+ */
+export function isBuildingDoorOffset(dx, dz, footprint, doorFacing = 'posZ', halfW = 0) {
     const { radiusX, radiusZ } = normalizeBuildingFootprint(footprint);
     if (radiusX <= 0 || radiusZ <= 0)
         return false;
+    const alongX = doorFacing === 'posZ' || doorFacing === 'negZ';
+    const w = Math.max(0, Math.min(Math.floor(halfW), (alongX ? radiusX : radiusZ) - 1));
     if (doorFacing === 'posZ')
-        return dx === 0 && dz === radiusZ;
+        return Math.abs(dx) <= w && dz === radiusZ;
     if (doorFacing === 'negZ')
-        return dx === 0 && dz === -radiusZ;
+        return Math.abs(dx) <= w && dz === -radiusZ;
     if (doorFacing === 'posX')
-        return dx === radiusX && dz === 0;
-    return dx === -radiusX && dz === 0;
+        return dx === radiusX && Math.abs(dz) <= w;
+    return dx === -radiusX && Math.abs(dz) <= w;
 }
-export function buildingWallBlocksOffset(dx, dz, footprint, doorFacing = 'posZ') {
+export function buildingWallBlocksOffset(dx, dz, footprint, doorFacing = 'posZ', halfW = 0) {
     const { radiusX, radiusZ } = normalizeBuildingFootprint(footprint);
     if (radiusX <= 0 || radiusZ <= 0)
         return false;
@@ -923,15 +1069,21 @@ export function buildingWallBlocksOffset(dx, dz, footprint, doorFacing = 'posZ')
     const onWallRing = Math.abs(dx) === radiusX || Math.abs(dz) === radiusZ;
     if (!onWallRing)
         return false;
-    return !isBuildingDoorOffset(dx, dz, { radiusX, radiusZ }, doorFacing);
+    return !isBuildingDoorOffset(dx, dz, { radiusX, radiusZ }, doorFacing, halfW);
 }
-export function isBuildingInteriorOffset(dx, dz, footprint, doorFacing = 'posZ') {
+/**
+ * Inside the building for the roof hide: any footprint tile that is not a
+ * blocked ring tile (the door, or the whole mouth, counts as inside). Pass
+ * the mouth rule's `halfW` (buildingDoorHalfWidth(kind, style)) so the roof
+ * lifts across a wide mouth exactly where the collision opens it.
+ */
+export function isBuildingInteriorOffset(dx, dz, footprint, doorFacing = 'posZ', halfW = 0) {
     const { radiusX, radiusZ } = normalizeBuildingFootprint(footprint);
     if (radiusX <= 0 || radiusZ <= 0)
         return false;
     if (Math.abs(dx) > radiusX || Math.abs(dz) > radiusZ)
         return false;
-    return !buildingWallBlocksOffset(dx, dz, { radiusX, radiusZ }, doorFacing);
+    return !buildingWallBlocksOffset(dx, dz, { radiusX, radiusZ }, doorFacing, halfW);
 }
 export function boulderFootprintRadius(style, scale) {
     if (style !== 'boulder')
@@ -1199,6 +1351,97 @@ export function faceStyleDegrees(style) {
     const deg = Number(face[1]);
     return Number.isFinite(deg) ? deg : null;
 }
+export function parseGardenWallRun(style) {
+    const m = /^run-(\d+)-(ew|ns)(?:-(stone|hedge|noble|fence))?$/.exec(style ?? '');
+    if (!m)
+        return null;
+    const len = Number(m[1]);
+    if (!Number.isFinite(len) || len < 1)
+        return null;
+    return { len, alongX: m[2] === 'ew', look: m[3] ?? 'stone' };
+}
+export function gardenWallRunStyle(len, alongX, look = 'stone') {
+    return `run-${Math.max(1, Math.floor(len))}-${alongX ? 'ew' : 'ns'}${look === 'stone' ? '' : `-${look}`}`;
+}
+/** The walk-through gate piece for a wall of `look`: noble walls take the iron gate. */
+export function gardenWallGateStyle(alongX, look = 'stone') {
+    const token = look === 'noble' ? 'iron' : look === 'stone' ? '' : look;
+    return `gate${token ? `-${token}` : ''}-${alongX ? 'ew' : 'ns'}`;
+}
+export function isGardenWallGateStyle(style) {
+    return typeof style === 'string' && style.startsWith('gate');
+}
+/** The tiles a gardenwall blocks: a whole run, one piece, or nothing for a gate. */
+export function visitGardenWallOffsets(style, visit) {
+    if (isGardenWallGateStyle(style))
+        return;
+    const run = parseGardenWallRun(style);
+    if (!run) {
+        visit(0, 0);
+        return;
+    }
+    for (let i = 0; i < run.len; i++) {
+        if (run.alongX)
+            visit(i, 0);
+        else
+            visit(0, i);
+    }
+}
+/* ------------------------------------------------------------------ *
+ * Tree groves (the Capital redesign, 2026-09-25): a clump of trees drawn as
+ * ONE entity with one mesh per material, for the city's orchards, gardens
+ * and verges. Style `grove-<3|5>[-<species>][-scenic]`: a 3 x 3 clump of
+ * three trees or a 5 x 5 clump of five, about the entity's tile. Each trunk
+ * stands on the tile TREE_GROVE_TRUNKS gives it (the frontend plants the
+ * trees exactly there) and blocks that tile only; the canopy between is
+ * walk-under, as it is round a single tree. A grove is never cut down
+ * (woodwork.ts isCuttableTreeStyle).
+ * ------------------------------------------------------------------ */
+export const TREE_GROVE_TRUNKS = {
+    'grove-3': [[-1, -1], [1, -1], [0, 1]],
+    'grove-5': [[-2, -2], [1, -2], [-1, 0], [2, 1], [-1, 2]],
+};
+/** The grove size a tree style names (3 or 5), or null for a single tree. */
+export function treeGroveSize(style) {
+    if (!style)
+        return null;
+    if (style === 'grove-3' || style.startsWith('grove-3-'))
+        return 3;
+    if (style === 'grove-5' || style.startsWith('grove-5-'))
+        return 5;
+    return null;
+}
+/** The trunk tiles of a grove style, about its entity tile, or null for a single tree. */
+export function treeGroveTrunks(style) {
+    const size = treeGroveSize(style);
+    return size === null ? null : TREE_GROVE_TRUNKS[size === 3 ? 'grove-3' : 'grove-5'];
+}
+/*
+ * Statue plinths (the Capital's monuments, 2026-09-25 review): a `statue`
+ * whose style carries a `plinth3` or `plinth5` token stands on a stepped
+ * stone plinth three or five tiles square about its tile, and the whole
+ * square blocks (visitBlockedWalkOffsets). Style `<figure>[-plinth<3|5>][-<facing>]`,
+ * e.g. `king-plinth5`, `knight-plinth3-w`: the figure token first (the asset
+ * reads `king` / `knight` from it) and the facing last, so a statue without
+ * the token is the one-tile statue it always was.
+ */
+export function statuePlinthSize(style) {
+    const tokens = (style ?? '').split('-');
+    if (tokens.includes('plinth5'))
+        return 5;
+    if (tokens.includes('plinth3'))
+        return 3;
+    return 0;
+}
+/** A statue style with its plinth token, the facing (if any) kept last. */
+export function statueStyleWithPlinth(style, size) {
+    if (!size)
+        return style;
+    const tokens = style.split('-').filter((t) => t !== 'plinth3' && t !== 'plinth5');
+    const last = tokens[tokens.length - 1];
+    const facing = tokens.length > 1 && (last === 'n' || last === 's' || last === 'e' || last === 'w') ? tokens.pop() : undefined;
+    return [...tokens, `plinth${size}`, ...(facing ? [facing] : [])].join('-');
+}
 /**
  * A work bench is a long table: 2.2 units along its local X and 1.0 deep at
  * scale 1 (createWorkBenchAsset; the mine's is the same shape), so at the
@@ -1340,6 +1583,30 @@ export function visitBlockedWalkOffsets(kind, style, scale, visit, doorFacing =
         }
         return;
     }
+    if (kind === 'capitalbuilding') {
+        // The Blender buildings (CAPITAL_BUILDING_MODELS). The facing always
+        // comes from the style, whatever door facing the caller passed, so a
+        // stamp without the door flag still agrees with the client.
+        const model = capitalBuildingModel(style);
+        if (!model) {
+            visit(0, 0);
+            return;
+        }
+        const fp = buildingFootprintExtents(kind, scale, style);
+        const facing = stoneHouseDoorFacing(style);
+        const halfW = buildingDoorHalfWidth(kind, style);
+        for (let dz = -fp.radiusZ; dz <= fp.radiusZ; dz++) {
+            for (let dx = -fp.radiusX; dx <= fp.radiusX; dx++) {
+                if (model.solid || buildingWallBlocksOffset(dx, dz, fp, facing, halfW))
+                    visit(dx, dz);
+            }
+        }
+        for (const [lx, lz] of model.frontProps ?? []) {
+            const [dx, dz] = turnBuildingOffset(lx, lz, facing);
+            visit(dx, dz);
+        }
+        return;
+    }
     if (kind === 'citywall') {
         visitCityWallOffsets(style, visit);
         return;
@@ -1349,11 +1616,18 @@ export function visitBlockedWalkOffsets(kind, style, scale, visit, doorFacing =
         return;
     }
     if (kind === 'gardenwall') {
-        if (style?.startsWith('gate'))
-            return;
-        visit(0, 0);
+        visitGardenWallOffsets(style, visit);
         return;
     }
+    if (kind === 'tree') {
+        // A grove blocks its trunks; a single tree falls through to its own tile.
+        const trunks = treeGroveTrunks(style);
+        if (trunks) {
+            for (const [dx, dz] of trunks)
+                visit(dx, dz);
+            return;
+        }
+    }
     if (kind === 'fountain') {
         // The basin: three by three about the centre.
         for (let dz = -1; dz <= 1; dz++) {
@@ -1362,6 +1636,18 @@ export function visitBlockedWalkOffsets(kind, style, scale, visit, doorFacing =
         }
         return;
     }
+    if (kind === 'statue') {
+        // A statue on a stepped plinth blocks the plinth's square; one without
+        // a plinth token falls through to its own tile.
+        const half = (statuePlinthSize(style) - 1) / 2;
+        if (half > 0) {
+            for (let dz = -half; dz <= half; dz++) {
+                for (let dx = -half; dx <= half; dx++)
+                    visit(dx, dz);
+            }
+            return;
+        }
+    }
     if (kind === 'brokengate') {
         // Posts and wreckage across three tiles; nobody climbs the splinters.
         const acrossZ = frostSpanAcrossZ(style);
@@ -1387,6 +1673,29 @@ export function visitBlockedWalkOffsets(kind, style, scale, visit, doorFacing =
         }
         return;
     }
+    if (kind === 'marketstall') {
+        // A stall is a counter two tiles wide under an awning, and the trailing
+        // letter of the style says which way it fronts. Only its middle tile was
+        // ever solid, so both ends of the counter were walk-through (James,
+        // 2026-09-22: "I can walk through market stalls"). Hope Beach's coastal
+        // stalls are the big ones, five along the counter with their barrels -
+        // the same shape hopeBeach.ts already stamps on the server, now shared
+        // with the client so its prediction agrees.
+        const facing = typeof style === 'string' ? style.charAt(style.length - 1) : 's';
+        const alongZ = facing === 'e' || facing === 'w';
+        const coastal = typeof style === 'string' && style.startsWith('coastal-');
+        const half = coastal ? 2 : 1;
+        const deep = coastal ? 1 : 0;
+        for (let a = -half; a <= half; a++) {
+            for (let b = -deep; b <= deep; b++) {
+                if (alongZ)
+                    visit(b, a);
+                else
+                    visit(a, b);
+            }
+        }
+        return;
+    }
     if (kind === 'fence' && isFenceGateStyle(style)) {
         if (isOpenGateStyle(style))
             return;
@@ -1414,9 +1723,11 @@ export function visitBlockedWalkOffsets(kind, style, scale, visit, doorFacing =
     if (buildingFp.radiusX > 0 && buildingFp.radiusZ > 0) {
         // Hollow buildings: only the wall ring is solid. The origin is interior
         // floor - blocking it sealed the storage hut so you could never stand inside.
+        // The door is one tile, or a wider mouth by the mouth rule (a `mouth5` token).
+        const mouthHalfW = buildingDoorHalfWidth(kind, style);
         for (let dz = -buildingFp.radiusZ; dz <= buildingFp.radiusZ; dz++) {
             for (let dx = -buildingFp.radiusX; dx <= buildingFp.radiusX; dx++) {
-                if (!buildingWallBlocksOffset(dx, dz, buildingFp, doorFacing))
+                if (!buildingWallBlocksOffset(dx, dz, buildingFp, doorFacing, mouthHalfW))
                     continue;
                 // Cottage is a walk-through: south porch door and north garden door.
                 if (kind === 'farmhut' &&