@dreadwood-types/types 0.1.47 → 0.1.51

package/dist/capital.d.ts

@@ -2,22 +2,42 @@
  * THE CAPITAL
  *
  * The walled capital of the northern kingdoms, in the open green east of the
- * Thaw, redesigned 2026-09-18 from James' picture and brief: a fortress
- * city on one axis. The Royal Way runs west to east from the main gate
- * straight at the keep, which stands on a raised mound at the east end so
- * it is above the roofline from the moment you step off the bridge. Every
- * district is a block off that axis, packed with terraced rowhouses; the
- * only lawns are the temple cloister and the noble gardens, both walled.
+ * Thaw. Redesigned 2026-09-25 from James's masterplan and district sheets
+ * (design-references/capital-*; the layout spec and its checking plan script
+ * are summarised in the phase-1 commit). The plan in one breath:
+ *
+ * - One north-south spine, the Royal Way (u 149-155), from the North Gate
+ *   past Victory Plaza, the Crown Cross and the Noble Cross to the South
+ *   Gate. Both of those gates are built and barred.
+ * - Two east-west primaries: Crown Street (v 62-66) the full width of the
+ *   city on the painted road, and the King's Road (v 82-86, the keep axis,
+ *   CAPITAL_AVENUE_Z) from the Great Gate in the west wall to the Crown
+ *   Cross and up the ramp to the keep. The Harbour Road runs the same rows
+ *   from the East Gate to the mound's foot.
+ * - The keep on its mound east of the Way, still facing west; the districts
+ *   where the masterplan paints them: Trade NW, Temple Gardens NE, the
+ *   Westgate Outpost, Forge and Military Ward west of the Way, the Keep and
+ *   the Royal Quarter centre-east, the Noble Quarter SE.
+ *
+ * CITY-LOCAL TILES. Every plan table below is written in city-local tiles,
+ * `u = x - CAPITAL_MIN_X` (0..280, west to east) and `v = z - CAPITAL_NORTH_Z`
+ * (0..168, north to south): the walls are u 0-1, u 279-280, v 0-1 and
+ * v 167-168, the buildable interior u 2-278, v 2-166. `cu()` / `cv()` turn
+ * them into world tiles; every row also carries its world rect or tile, so
+ * nothing downstream has to convert by hand. Never write a world literal for
+ * a Capital coordinate: the map has already moved under the city once.
  *
  * World tiles; the north pad is part of the grid, so no toWorldZ.
  * Backend builder: capitalCity.ts. Assets: capitalAssets.ts (keep, statue,
- * fountain), capitalFabric.ts (walls, gatehouse, bridge, buildings, props).
+ * fountain), capitalFabric.ts (walls, gatehouse, bridge, buildings, props),
+ * buildingModels.ts (the Blender buildings, kind `capitalbuilding`).
  */
+import { SurfaceType, type EntityKind } from './constants.js';
 /** The outer wall: two tiles thick, these are the OUTER rows. */
 export declare const CAPITAL_MIN_X = 480;
 export declare const CAPITAL_MAX_X = 760;
-export declare const CAPITAL_NORTH_Z = 12;
-export declare const CAPITAL_SOUTH_Z = 180;
+export declare const CAPITAL_NORTH_Z = 76;
+export declare const CAPITAL_SOUTH_Z = 244;
 export declare const CAPITAL_WALL_THICK = 2;
 export declare const CAPITAL_BASTION_EVERY = 16;
 /** Inside the wall: the first row a building can stand on. */
@@ -25,18 +45,46 @@ export declare const CAPITAL_INNER_MIN_X: number;
 export declare const CAPITAL_INNER_MAX_X: number;
 export declare const CAPITAL_INNER_NORTH_Z: number;
 export declare const CAPITAL_INNER_SOUTH_Z: number;
+/** City-local column to world x: u 0 is the west wall's outer row. */
+export declare function cu(u: number): number;
+/** City-local row to world z: v 0 is the north wall's outer row. */
+export declare function cv(v: number): number;
+/** World x back to a city-local column. */
+export declare function capU(x: number): number;
+/** World z back to a city-local row. */
+export declare function capV(z: number): number;
+/** A city-local tile as a world tile. */
+export declare function capWorld(u: number, v: number): {
+    x: number;
+    z: number;
+};
+/** A city-local rect (inclusive) as a world rect (inclusive). */
+export declare function capWorldRect(r: {
+    u0: number;
+    u1: number;
+    v0: number;
+    v1: number;
+}): {
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+};
 /** The moat: eight tiles of water outside the wall; the north side runs into the sea. */
 export declare const CAPITAL_MOAT_W = 8;
 export declare const CAPITAL_MOAT_MIN_X: number;
 export declare const CAPITAL_MOAT_MAX_X: number;
-export declare const CAPITAL_MOAT_NORTH_Z = 3;
+export declare const CAPITAL_MOAT_NORTH_Z: number;
 export declare const CAPITAL_MOAT_SOUTH_Z: number;
+/** The King's Road's rows: the keep axis, the Great Gate and the East Gate. 160 after the northern extension. */
+export declare const CAPITAL_AVENUE_Z: number;
+export declare const CAPITAL_AVENUE_HALF_W = 2;
 /** The basin before the main gate: the moat widened west so the bridge is long. */
 export declare const CAPITAL_POOL: {
-    readonly minX: 456;
+    readonly minX: number;
     readonly maxX: number;
-    readonly minZ: 74;
-    readonly maxZ: 118;
+    readonly minZ: number;
+    readonly maxZ: number;
 };
 /** Ground inside the walls; the bank outside the moat; the water. */
 export declare const CAPITAL_FLOOR_H = 2;
@@ -44,209 +92,505 @@ export declare const CAPITAL_BANK_H = 1;
 export declare const CAPITAL_MOAT_H = 0;
 /** Everything the city owns, for the sweep, the levelling and the discovery zone. */
 export declare const CAPITAL_WORKS: {
-    readonly minX: 436;
+    readonly minX: number;
     readonly maxX: number;
-    readonly minZ: 3;
-    readonly maxZ: 191;
+    readonly minZ: number;
+    readonly maxZ: number;
 };
-/** The Royal Way: five wide on the gate's rows, the keep's axis. */
-export declare const CAPITAL_AVENUE_Z = 96;
-export declare const CAPITAL_AVENUE_HALF_W = 2;
-/** The main gate in the west wall, the three side gates. Passage is five wide. */
+/** The Royal Way: seven wide (u 149-155, Path kerbs on its outer columns), a grass verge four wide either side. */
+export declare const CAPITAL_ROYAL_WAY_X: number;
+export declare const CAPITAL_ROYAL_WAY_HALF_W = 3;
+export declare const CAPITAL_ROYAL_WAY_VERGE = 4;
+/** Crown Street, five wide on the painted road (v 62-66). */
+export declare const CAPITAL_CROWN_Z: number;
+/** The Noble Walk, five wide along the mound's south foot (v 102-106). */
+export declare const CAPITAL_NOBLE_WALK_Z: number;
+/** Primary routes are five wide: half-width two, Stone with Path kerb rows. */
+export declare const CAPITAL_PRIMARY_HALF_W = 2;
+/** Every gate passage is five wide. */
 export declare const CAPITAL_GATE_HALF_W = 2;
+/** The Great Gate in the west wall, open: the land arrival (decision D1-B, unchanged). */
 export declare const CAPITAL_MAIN_GATE: {
     readonly x: 480;
-    readonly z: 96;
+    readonly z: number;
 };
+/** The East Gate, open: the harbour's Dock Gate. */
 export declare const CAPITAL_EAST_GATE: {
     readonly x: 760;
-    readonly z: 96;
+    readonly z: number;
 };
+/** The North Gate at the Way's north end: built, barred (the sea is beyond it). */
 export declare const CAPITAL_NORTH_GATE: {
-    readonly x: 620;
-    readonly z: 12;
+    readonly x: number;
+    readonly z: 76;
 };
+/**
+ * The South Gate at the Way's south end, the Dreadwoods gate. Open since
+ * James's word on D2 (2026-09-25, "yes we should add a pathway to
+ * dreadwoods"): the South Bridge carries the Way over the moat to the
+ * Dreadwoods north gate, straight into the PvP woods.
+ */
 export declare const CAPITAL_SOUTH_GATE: {
-    readonly x: 620;
-    readonly z: 180;
+    readonly x: number;
+    readonly z: 244;
+};
+/**
+ * The four city gates as the builder places them. `style` is the gatehouse
+ * style (constants.ts `visitGatehouseOffsets`): a `shut` token keeps the
+ * passage blocked in the shared collision, so a barred gate needs nothing
+ * else from the builder, and the wall rows under it stay unpaved. The
+ * facing letter is always the LAST token (the frontend turns by it).
+ */
+export declare const CAPITAL_GATES: ReadonlyArray<{
+    id: 'west' | 'east' | 'north' | 'south';
+    name: string;
+    x: number;
+    z: number;
+    style: string;
+    open: boolean;
+}>;
+/** The first interior tile inside each open gate's passage, where the walks are measured from. */
+export declare const CAPITAL_WEST_MOUTH: {
+    readonly u: 2;
+    readonly v: 84;
+    readonly x: number;
+    readonly z: number;
+};
+export declare const CAPITAL_EAST_MOUTH: {
+    readonly u: number;
+    readonly v: 84;
+    readonly x: number;
+    readonly z: number;
 };
 /** The bridge over the pool: seven rows, the outer two carry the parapet and the knights. */
 export declare const CAPITAL_BRIDGE_MIN_X: number;
 /** The bridge's crown: the middle third of the deck stands one height up. */
 export declare const CAPITAL_BRIDGE_CROWN_H: number;
-/** Small plazas where the cross streets meet the Royal Way: the Way widened by two rows each side. */
-export declare const CAPITAL_WAY_PLAZA_HALF_X = 4;
-export declare const CAPITAL_WAY_PLAZA_HALF_Z: number;
 export declare const CAPITAL_BRIDGE_MAX_X: number;
 export declare const CAPITAL_BRIDGE_HALF_W = 3;
 /** The barbican on the far bank, astride the road before the bridge. */
 export declare const CAPITAL_BARBICAN: {
     readonly x: number;
-    readonly z: 96;
+    readonly z: number;
 };
 export declare const CAPITAL_BRIDGE_KNIGHTS: ReadonlyArray<{
     x: number;
     z: number;
     facing: 'n' | 's' | 'e' | 'w';
 }>;
-/** The ring road inside the wall, and the street grid. Streets are three wide about these lines. */
-export declare const CAPITAL_RING_INSET = 1;
-export declare const CAPITAL_STREET_HALF_W = 1;
-export declare const CAPITAL_CROSS_STREET_XS: readonly [540, 580, 620, 660];
 /**
- * The primary routes (the readability pass, 2026-09-19): five wide with
- * kerb rows like the Way, so the player reads them as the way to somewhere.
- * The Way itself goes gate to keep; these go Way to market, Way to the
- * garrison, Way to the temple (the cross street and the Temple Walk along
- * the square's south side). Every other street is three wide.
+ * The South Bridge (D2): the Way's seven rows carried on over the south moat,
+ * from the South Gate's passage to the grass strip under the Dreadwoods
+ * north wall. The deck is terrain at the city floor, the parapets run along
+ * its east and west edges.
  */
-export declare const CAPITAL_PRIMARY_HALF_W = 2;
-export declare const CAPITAL_PRIMARY_ROUTES: ReadonlyArray<{
-    x?: number;
-    z?: number;
-    min: number;
-    max: number;
-}>;
-/** East-west district streets as segments; the Way itself is separate. */
-export declare const CAPITAL_DISTRICT_STREETS: ReadonlyArray<{
-    z: number;
-    minX: number;
-    maxX: number;
-}>;
+export declare const CAPITAL_SOUTH_BRIDGE: {
+    readonly minX: number;
+    readonly maxX: number;
+    readonly minZ: number;
+    readonly maxZ: number;
+};
+/** The rows that cross water (the moat); the rest of the bridge is its landing on the strip. */
+export declare const CAPITAL_SOUTH_BRIDGE_DECK_MAX_Z: number;
+export declare function onCapitalSouthBridge(x: number, z: number): boolean;
+/** The Dreadwoods gate the South Bridge meets: five tiles cut from the woods' north wall on the Way's line. */
+export declare const DREADWOODS_NORTH_GATE_X: number;
+export declare const DREADWOODS_NORTH_GATE_HALF_W = 2;
+export declare function inDreadwoodsNorthGate(x: number, z: number): boolean;
+/** The road in, gate throat included, until it gives out in the ash. */
+export declare const DREADWOODS_NORTH_ROAD_INNER_TILES = 8;
+export declare function inDreadwoodsNorthRoad(x: number, z: number): boolean;
+/** The ring lane inside the wall: three wide, one tile in (u 2-4, u 276-278, v 2-4, v 164-166). */
+export declare const CAPITAL_RING_INSET = 1;
+export declare const CAPITAL_STREET_HALF_W = 1;
 /**
  * The keep's mound: a plateau at CAPITAL_MOUND_H with a slope of one height
- * a tile all round it, the Royal Way climbing the west slope as a ramp.
+ * a tile all round it (u 160-220, v 66-102), the King's Road climbing the
+ * west slope as the ramp (u 160-165) to the Inner Gate. Crown Street runs on
+ * its north foot, the Noble Walk on its south foot, the Harbour Road stops at
+ * its east foot.
  */
 export declare const CAPITAL_MOUND_H = 8;
 export declare const CAPITAL_PLATEAU: {
-    readonly minX: 698;
-    readonly maxX: 746;
-    readonly minZ: 84;
-    readonly maxZ: 108;
+    readonly minX: number;
+    readonly maxX: number;
+    readonly minZ: number;
+    readonly maxZ: number;
 };
-export declare const CAPITAL_MOUND_SLOPE: number;
-/** The inner gatehouse on the plateau's west edge, and the curtain round the edge. */
+/** The inner gatehouse on the plateau's west edge; the curtain runs round the edge with this one gap. */
 export declare const CAPITAL_INNER_GATE: {
     readonly x: number;
-    readonly z: 96;
+    readonly z: number;
 };
-/** The keep and the inner court before it. */
+/**
+ * The keep, thirty tiles in from the plateau's west edge, door west onto the
+ * Audience Court (decision D3 default). Its half-extents are constants.ts's
+ * CASTLE_KEEP_HALF_X/Z (the collision and the asset read those).
+ */
 export declare const CAPITAL_KEEP: {
-    readonly x: 728;
-    readonly z: 96;
+    readonly x: number;
+    readonly z: number;
 };
-export declare const CAPITAL_KEEP_HALF_X = 12;
-export declare const CAPITAL_KEEP_HALF_Z = 9;
+/** The King's Statue in the Audience Court, between the Inner Gate and the keep door. */
 export declare const CAPITAL_KING_STATUE: {
-    readonly x: 708;
-    readonly z: 96;
-};
-/** The squares: paved, reserved from building. */
-export declare const CAPITAL_MARKET_SQUARE: {
-    readonly minX: 486;
-    readonly maxX: 538;
-    readonly minZ: 16;
-    readonly maxZ: 54;
-};
-export declare const CAPITAL_MARKET_FOUNTAIN: {
-    readonly x: 512;
-    readonly z: 35;
-};
-export declare const CAPITAL_COIN_SQUARE: {
-    readonly minX: 622;
-    readonly maxX: 658;
-    readonly minZ: 38;
-    readonly maxZ: 53;
-};
-export declare const CAPITAL_COIN_FOUNTAIN: {
-    readonly x: 640;
-    readonly z: 46;
-};
-export declare const CAPITAL_TEMPLE_SQUARE: {
-    readonly minX: 684;
-    readonly maxX: 716;
-    readonly minZ: 40;
-    readonly maxZ: 74;
-};
-export declare const CAPITAL_DRILL_SQUARE: {
-    readonly minX: 604;
-    readonly maxX: 636;
-    readonly minZ: 120;
-    readonly maxZ: 136;
-};
-export declare const CAPITAL_TRAINING_YARD: {
-    readonly minX: 598;
-    readonly maxX: 642;
-    readonly minZ: 140;
-    readonly maxZ: 154;
-};
-/** The greens: the graveyard and cloister by the temple, and the noble gardens. */
-export declare const CAPITAL_GRAVEYARD: {
-    readonly minX: 664;
-    readonly maxX: 688;
-    readonly minZ: 16;
-    readonly maxZ: 32;
-};
-export declare const CAPITAL_CLOISTER: {
-    readonly minX: 712;
-    readonly maxX: 750;
-    readonly minZ: 16;
-    readonly maxZ: 32;
-};
-export declare const CAPITAL_NOBLE_GARDENS: ReadonlyArray<{
-    minX: number;
-    maxX: number;
-    minZ: number;
-    maxZ: number;
-    manor: {
-        x: number;
-        z: number;
-        roof: string;
-    };
-}>;
+    readonly x: number;
+    readonly z: number;
+};
+/** The King's Fountain on the Way's axis in the Crown Cross; the Way splits round it. */
+export declare const CAPITAL_KINGS_FOUNTAIN: {
+    readonly x: number;
+    readonly z: number;
+};
 /**
- * The landmarks: walk-in buildings by kind and style. `board` puts a notice
- * board at the door for the ones whose trade is not on their face.
+ * The stand in the Drill Square with a clear three-tile ring round it: the
+ * outfit capture pass, walk-capture and the smokes' closing /tp use it.
  */
-export declare const CAPITAL_LANDMARKS: ReadonlyArray<{
-    id: string;
-    kind: 'stonehouse' | 'temple' | 'forgehall' | 'warehouse' | 'manor';
-    style: string;
+export declare const CAPITAL_DRILL_STAND: {
+    readonly x: number;
+    readonly z: number;
+};
+/** The road in: from the Thaw arch's east road, round to the barbican. */
+export declare const CAPITAL_ROAD: ReadonlyArray<{
     x: number;
     z: number;
-    board?: string;
 }>;
-/** The market's stall rows: x, z, facing; four rows across the square. */
-export declare const CAPITAL_STALL_ROWS: ReadonlyArray<{
+/** A city-local rect, inclusive, with its world rect. */
+export type CapRect = {
+    readonly id: string;
+    readonly u0: number;
+    readonly u1: number;
+    readonly v0: number;
+    readonly v1: number;
+    readonly minX: number;
+    readonly maxX: number;
+    readonly minZ: number;
+    readonly maxZ: number;
+};
+/** A city-local tile with its world tile. */
+export type CapTile = {
+    readonly u: number;
+    readonly v: number;
+    readonly x: number;
+    readonly z: number;
+};
+/** The district identities (spec A.4): banner emblems and roof tokens. */
+export type CapitalEmblem = 'tree' | 'scales' | 'crown' | 'anvil' | 'hammers-red' | 'lion' | 'cross' | 'trident' | 'anchor';
+/** Roof colour tokens: blue slate everywhere in the Capital; the four manors are blue, green, red and purple. */
+export type CapitalRoofToken = 'blue' | 'green' | 'red' | 'purple' | 'slate' | 'tan';
+/**
+ * Ground tokens and the surface each is laid in. The Capital's paving
+ * (frontend CapitalPaving.ts) draws Stone as big flags and Path as setts, so
+ * 'flag' is Stone and 'setts' is Path. There is no gravel surface yet: the
+ * temple and noble walks are laid as Path until there is one.
+ */
+export type CapitalGround = 'stone' | 'flag' | 'setts' | 'path' | 'gravel' | 'dirt' | 'grass';
+export declare function capitalSurface(ground: CapitalGround): SurfaceType;
+/**
+ * The routes (spec A.2). `primary` and `way` are the wide stone roads with
+ * Path kerb rows on their outer rows (kerb: true); lanes and walks take their
+ * district's ground. Lamps stand every `lamps.every` tiles on the kerbs,
+ * alternating sides, never on the paving. The Way's verges (grass, `verge`
+ * tiles wide either side) carry a tree every 8 alternating with a crown pole
+ * every 8 on the kerbs; inside a plaza the verge is paved over.
+ */
+export type CapitalRouteKind = 'primary' | 'way' | 'lane' | 'walk';
+export type CapitalRoute = CapRect & {
+    readonly name: string;
+    readonly kind: CapitalRouteKind;
+    readonly surface: Extract<CapitalGround, 'stone' | 'flag' | 'path' | 'gravel' | 'dirt'>;
+    readonly kerb?: boolean;
+    readonly lamps?: {
+        readonly every: number;
+        readonly alternate: boolean;
+    };
+    readonly verge?: number;
+};
+export declare const CAPITAL_ROUTES: ReadonlyArray<CapitalRoute>;
+/**
+ * The plazas, squares, courts and door aprons (spec A.3). `apron` rows are
+ * the paved strips that join a door to a route. `forLandmark` names the
+ * building an apron serves: until that building stands (capitalPlacementNow),
+ * the apron is not laid and the ground under it shows through (paving that
+ * ends at nothing reads as unfinished work). The row stays in the table, so
+ * the rect stays reserved and the later phase needs no re-plan.
+ */
+export type CapitalPlaza = CapRect & {
+    readonly name: string;
+    readonly surface: Extract<CapitalGround, 'stone' | 'setts' | 'flag' | 'gravel'>;
+    readonly apron?: boolean;
+    readonly forLandmark?: string;
+};
+export declare const CAPITAL_PLAZAS: ReadonlyArray<CapitalPlaza>;
+/**
+ * The greens: lawns, gardens, orchards, the graveyard, the paddock and the
+ * Way's verges. A `wall` rings the rect's edge tiles (the builder lays one
+ * gardenwall run entity per straight run, constants.ts `gardenWallRunStyle`)
+ * except at the `gates` tiles, which are openings (a gate piece, or nothing
+ * for a wide opening). `groves` is how many merged grove entities
+ * (`tree grove-3` / `grove-5`) to scatter on the tiles that end as lawn,
+ * seeded by the row's id so moving anything else reshuffles nothing.
+ */
+export type CapitalGreenKind = 'lawn' | 'garden' | 'orchard' | 'graveyard' | 'paddock' | 'verge';
+export type CapitalWallLook = 'garden' | 'hedge' | 'noble' | 'fence';
+export type CapitalGreen = CapRect & {
+    readonly name: string;
+    readonly kind: CapitalGreenKind;
+    readonly wall?: CapitalWallLook;
+    readonly gates?: ReadonlyArray<readonly [number, number]>;
+    readonly groves?: number;
+};
+export declare const CAPITAL_GREENS: ReadonlyArray<CapitalGreen>;
+/**
+ * The working yards (Dirt). A fenced yard is ringed by a fence run with its
+ * `gates` tiles open (the Charcoal Yard's nine are its open side onto Anvil
+ * Square). Gates listed off the ring are harmless (the plan script kept one
+ * on the Drill Lane). A yard with a later `phase` than CAPITAL_BUILD_PHASE is
+ * not laid yet: its ground stays lawn (a bare dirt lot with nothing in it
+ * reads as unfinished).
+ */
+export type CapitalYard = CapRect & {
+    readonly name: string;
+    readonly surface: Extract<CapitalGround, 'dirt' | 'stone'>;
+    readonly fence?: boolean;
+    readonly gates?: ReadonlyArray<readonly [number, number]>;
+    readonly phase?: 1 | 2 | 3;
+};
+export declare const CAPITAL_YARDS: ReadonlyArray<CapitalYard>;
+export type CapitalDistrictId = 'capital-castle' | 'capital-merchant' | 'capital-gate' | 'capital-market' | 'capital-smiths' | 'capital-garrison' | 'capital-temple' | 'capital-noble';
+export type CapitalDistrict = CapRect & {
+    readonly id: CapitalDistrictId;
+    readonly label: string;
+    readonly street: 'path' | 'dirt' | 'stone' | 'gravel';
+    readonly roofs: ReadonlyArray<CapitalRoofToken>;
+    readonly emblem: CapitalEmblem;
+};
+export declare const CAPITAL_DISTRICTS: ReadonlyArray<CapitalDistrict>;
+/**
+ * The phase the city is built to. A plan row whose `phase` is later than
+ * this stands as its `standIn` if the stand-in's phase has come, and
+ * otherwise is not built yet; its footprint is still reserved, so the later
+ * phase lands on a clear plot and reshuffles nothing.
+ */
+export declare const CAPITAL_BUILD_PHASE: 1 | 2 | 3;
+/** Kinds a plan row can be placed as today (every one an EntityKind). */
+export type CapitalPlacedKind = Extract<EntityKind, 'stonehouse' | 'temple' | 'forgehall' | 'warehouse' | 'manor' | 'castle' | 'citywall' | 'capitalbuilding' | 'marketstall' | 'statue' | 'fountain' | 'hoodedstatue' | 'yardprop'>;
+/** Kinds the plan names for a later phase that do not exist yet (the phase-2 shed, the phase-3 crypt). */
+export type CapitalFutureKind = 'shed' | 'mausoleum';
+export type CapitalStandIn = {
+    readonly kind: CapitalPlacedKind;
+    readonly style: string;
+    /** When the stand-in arrives (default 1). */
+    readonly phase?: 1 | 2 | 3;
+    /** Its own centre when it is not the plot's (city-local). */
+    readonly u?: number;
+    readonly v?: number;
+};
+export type CapitalFacing = 'n' | 's' | 'e' | 'w';
+/**
+ * A building's door as the plan checked it: the door tile on the footprint
+ * ring (the middle of the facing side) and the mouth width (1 for a door;
+ * 3, 5 or 7 for an open-fronted shed or hall). The approach tile is the one
+ * outside it; nothing may stand on either.
+ */
+export type CapitalDoor = CapTile & {
+    readonly facing: CapitalFacing;
+    readonly mouth: number;
+};
+export type CapitalLandmark = {
+    readonly id: string;
+    readonly name: string;
+    readonly district: CapitalDistrictId;
+    /** The final building (at `phase`). */
+    readonly kind: CapitalPlacedKind | CapitalFutureKind;
+    readonly style: string;
+    readonly phase: 1 | 2 | 3;
+    readonly standIn?: CapitalStandIn;
+    /** Centre tile. */
+    readonly u: number;
+    readonly v: number;
+    readonly x: number;
+    readonly z: number;
+    /** The plot the plan reserved (the final building's footprint). */
+    readonly footprint: CapRect;
+    /** null for a solid building (no way in). */
+    readonly door: CapitalDoor | null;
+    /** Paved forecourt, lights and (civic fronts) banners, as heroFront() lays them. */
+    readonly heroFront?: boolean;
+    /**
+     * A free-standing placard naming the place (never a trade description),
+     * stood beside the door's approach, never on its axis. Only for a front
+     * whose asset hangs no sign of its own (the stonehouse trade variants,
+     * bank, inn, lodge, clothes, shop, kitchen and potion, hang theirs), and
+     * only once something inside serves the player: the halls standing in for
+     * the Guild Hall, the Barracks and the Royal Administration get theirs
+     * with their staff (phase 2).
+     */
+    readonly board?: string;
+    readonly emblem?: CapitalEmblem;
+};
+/**
+ * The buildings, in placing order (spec B, plan script `B`). Phase-1 rows
+ * are REUSE kinds on their final plots; the Grand Exchange stands as its
+ * Blender building (decision D5); the Capital Bank, the Royal
+ * Administration and the Barracks stand as their stand-ins; the sheds, the
+ * new stonehouse variants and the crypt wait for phases 2 and 3.
+ */
+export declare const CAPITAL_LANDMARKS: ReadonlyArray<CapitalLandmark>;
+/**
+ * The monuments: statues and fountains on their plinths, solid. `size` is
+ * the square the plan reserves (a 5x5 stepped plinth, or 3x3): a statue
+ * fills and blocks it with its stepped plinth, a 3x3 fountain basin stands
+ * in the middle of a 5x5; keep dressing off the whole square.
+ */
+export type CapitalMonument = {
+    readonly id: string;
+    readonly name: string;
+    readonly district: CapitalDistrictId;
+    readonly kind: Extract<CapitalPlacedKind, 'statue' | 'fountain' | 'capitalbuilding' | 'hoodedstatue'>;
+    readonly style: string;
+    readonly phase: 1 | 2 | 3;
+    readonly standIn?: CapitalStandIn;
+    readonly u: number;
+    readonly v: number;
+    readonly x: number;
+    readonly z: number;
+    readonly size: 3 | 5;
+    readonly footprint: CapRect;
+};
+export declare const CAPITAL_MONUMENTS: ReadonlyArray<CapitalMonument>;
+/**
+ * What stands for a plan row in `phase` (default CAPITAL_BUILD_PHASE): the
+ * row itself once its phase has come, else its stand-in once the stand-in's
+ * phase has come, else null (not built yet; the plot stays reserved).
+ */
+export declare function capitalPlacementNow(row: {
+    kind: CapitalPlacedKind | CapitalFutureKind;
+    style: string;
+    phase: 1 | 2 | 3;
+    u: number;
+    v: number;
+    standIn?: CapitalStandIn;
+}, phase?: number): {
+    kind: CapitalPlacedKind;
+    style: string;
+    u: number;
+    v: number;
+    x: number;
     z: number;
-    facing: 'n' | 's';
-    minX: number;
-    maxX: number;
-}>;
-/** Stall pitch along a row. */
-export declare const CAPITAL_STALL_PITCH = 3;
-/** The districts, for discovery and the density pass. Roof tokens are the rowhouse palette. */
-export declare const CAPITAL_DISTRICTS: ReadonlyArray<{
+    standIn: boolean;
+} | null;
+/** The tiles a door opens on the ring: its middle tile and the rest of its mouth, along the facing side. */
+export declare function capitalDoorTiles(door: CapitalDoor): CapTile[];
+/** The approach tiles: one step out from each door tile. Nothing may stand on these (nor on the door). */
+export declare function capitalDoorApproach(door: CapitalDoor): CapTile[];
+/**
+ * The working stations (spec B.11), each on its exact tile: the builder
+ * places them with tileProp and asserts (throws in dev, logs in prod); the
+ * smoke checks each exists unsnapped with a free standable tile within
+ * `range` (the game's own reach constant). `inside` is the landmark it
+ * belongs to. Stoves and campfires must be placed at build time: world.ts
+ * registers cook spots once.
+ *
+ * Phase 1: 3 bank chests, 5 furnaces, 5 anvils, 3 charcoal mounds, 12
+ * training dummies, 2 shrines (bare: the ice-seal look until the Temple
+ * Altar style), the Cookhouse and inn stoves, the muster campfire, 4
+ * bounty boards and the Ranger Hall bench. The Main Forge's four stand in
+ * the open Furnace Yard until its building (phase 2).
+ */
+export type CapitalStation = CapTile & {
+    readonly id: string;
+    readonly kind: EntityKind;
+    readonly style?: string;
+    readonly scale?: number;
+    readonly range: number;
+    readonly inside?: string;
+    readonly phase: 1 | 2 | 3;
+};
+export declare const CAPITAL_STATIONS: ReadonlyArray<CapitalStation>;
+/**
+ * The market stalls: four clusters of three round a keeper's tile (the
+ * counters front outward, the keeper serves from the middle), plus the Food
+ * Court's row of three fronting the court. Style `<goods>-<facing>` as
+ * marketStall.ts reads it; the covered trader's cluster sells pots until its
+ * canopy restyle (phase 3). Keepers arrive in phase 2 (CAPITAL_NPC_SPOTS).
+ */
+export type CapitalStall = CapTile & {
+    readonly id: string;
+    readonly cluster: 'produce' | 'fish' | 'cloth' | 'trader' | 'food';
+    readonly goods: 'produce' | 'fish' | 'cloth' | 'pots';
+    readonly facing: CapitalFacing;
+    readonly style: string;
+    readonly phase: 1 | 2 | 3;
+};
+export declare const CAPITAL_STALLS: ReadonlyArray<CapitalStall>;
+/**
+ * Wayfinding and the gate braziers, placed by the plan and kept off every
+ * door approach. Fingerposts name places only; `capitalFingerpostStyle`
+ * builds their signpost style. The braziers stand beside the gate guards'
+ * tiles, never on them (finding F5).
+ */
+export type CapitalFixture = CapTile & {
+    readonly id: string;
+    readonly kind: 'signpost' | 'yardprop';
+    readonly style: string;
+    readonly names?: ReadonlyArray<string>;
+};
+/** A fingerpost's signpost style: `fingerpost-<place>|<place>|...`. The frontend draws one slat per place. */
+export declare function capitalFingerpostStyle(names: ReadonlyArray<string>): string;
+/** The places on a `fingerpost-` style, or null for any other style. */
+export declare function parseFingerpostStyle(style: string | undefined): string[] | null;
+export declare const CAPITAL_FIXTURES: ReadonlyArray<CapitalFixture>;
+/**
+ * The tiles the phase-2 NPC roster (spec B.10) will stand on. Nothing is
+ * spawned here in phase 1; the builder keeps these tiles free of dressing
+ * and furniture so the roster lands without moving anything. `role` is the
+ * intended kind (and shop), not yet an NpcKind.
+ */
+export type CapitalNpcSpot = CapTile & {
+    readonly id: string;
+    readonly name: string;
+    readonly role: string;
+};
+export declare const CAPITAL_NPC_SPOTS: ReadonlyArray<CapitalNpcSpot>;
+/**
+ * The Capital's guards (2026-09-21, redesigned 2026-09-25): level 40 in
+ * steel, in pairs, 14 of them. Inside the Great Gate, on the Audience Court
+ * either side of the keep's door, just inside the throne hall's door, inside
+ * the East Gate, at the harbour end of its bridge, and in the courts of the
+ * two barred gates. `faceX`/`faceZ` is what each pair watches. The hall pair
+ * is `still`: the hall's furniture is client-side and a pacing guard would
+ * walk through the feast tables. The first post is the admin links' Great
+ * Gate guard; keep it first.
+ */
+export declare const CAPITAL_GUARD_POSTS: ReadonlyArray<{
     id: string;
-    label: string;
-    minX: number;
-    maxX: number;
-    minZ: number;
-    maxZ: number;
-    roofs: ReadonlyArray<string>;
-    street: 'path' | 'dirt' | 'stone';
-}>;
-/** The road in: from the Thaw arch's east road, round to the barbican. */
-export declare const CAPITAL_ROAD: ReadonlyArray<{
     x: number;
     z: number;
+    faceX: number;
+    faceZ: number;
+    still?: true;
 }>;
+/**
+ * The walking budgets (spec A.6), read by capital-smoke.ts: an 8-way walk
+ * with no corner cutting from `from` to `to` must take at most `max` tiles.
+ * `to` is a landmark id (its door tile), a station id (the nearest tile
+ * within the station's range) or a tile (the nearest tile within `range`).
+ * `planned` is what the plan script measured.
+ */
+export type CapitalWalkBudget = {
+    readonly id: string;
+    readonly from: CapTile;
+    readonly to: string | (CapTile & {
+        readonly range?: number;
+    });
+    readonly max: number;
+    readonly planned: number;
+};
+export declare const CAPITAL_WALK_BUDGETS: ReadonlyArray<CapitalWalkBudget>;
 export declare function inCapitalWalls(x: number, z: number): boolean;
 /** Any tile of the two-thick outer wall. */
 export declare function onCapitalWall(x: number, z: number): boolean;
 export declare function inCapitalInterior(x: number, z: number): boolean;
-/** The passage tiles through each gate, the wall's own rows only. */
-export declare function inCapitalGate(x: number, z: number): boolean;
 export declare function onCapitalBridge(x: number, z: number): boolean;
 /**
  * The water of the moat and the pool, the bridge excepted. The wall side of
@@ -258,13 +602,45 @@ export declare function inCapitalMoat(x: number, z: number): boolean;
 export declare function inCapitalPlateau(x: number, z: number): boolean;
 /** The mound's height at a tile: the plateau, or the slope down from it, or the floor. */
 export declare function capitalMoundHeight(x: number, z: number): number;
-export declare function inCapitalKeep(x: number, z: number): boolean;
+/**
+ * The route on a tile, in paint order: the Royal Way over the primaries over
+ * the lanes and walks. Interior tiles only.
+ */
+export declare function capitalRouteAt(x: number, z: number): CapitalRoute | undefined;
+export declare function capitalPlazaAt(x: number, z: number): CapitalPlaza | undefined;
+export declare function capitalGreenAt(x: number, z: number): CapitalGreen | undefined;
+export declare function capitalYardAt(x: number, z: number): CapitalYard | undefined;
+export type CapitalGroundLayer = 'way' | 'primary' | 'lane' | 'walk' | 'plaza' | 'plateau' | 'mound' | 'green' | 'yard' | 'lawn';
+/**
+ * What the plan lays on an interior tile, in the builder's paint order
+ * (spec G.2): the Royal Way, then the primaries, the lanes and walks, the
+ * plazas, the mound (plateau Stone, banks Grass), the greens and yards, and
+ * lawn under everything. Kerb rows of the kerbed routes are Path. Buildings
+ * floor their own footprints on top (buildingFloorSurface); the gate
+ * passages and the keep are the builder's. What is not built in this phase
+ * is not laid: an apron whose building does not stand yet, a yard of a later
+ * phase (the rects stay in the tables, reserved).
+ */
+export declare function capitalGroundAt(x: number, z: number): {
+    layer: CapitalGroundLayer;
+    id?: string;
+    surface: SurfaceType;
+} | undefined;
+/** The ring lane inside the wall. */
 export declare function onCapitalRingRoad(x: number, z: number): boolean;
-/** The Royal Way, from the gate to the inner gate on the plateau's edge. */
+/** The Royal Way's paving (u 149-155, the North Gate to the South Gate). */
+export declare function onCapitalWay(x: number, z: number): boolean;
+/**
+ * The keep axis: the King's Road's rows from the Great Gate to the Inner
+ * Gate on the plateau's edge (it crosses the Way at the Crown Cross and
+ * climbs the ramp).
+ */
 export declare function onCapitalAvenue(x: number, z: number): boolean;
-/** A street tile: the Way, the ring road, the cross streets and the district streets, off the mound. */
-/** A primary route tile (not the Way): the wide streets to the market, garrison and temple. */
+/** A primary route tile (Crown Street, the King's Road and its ramp, the Harbour Road); not the Way. */
 export declare function onCapitalPrimary(x: number, z: number): boolean;
+/** A street tile: any route in the table (the Way, the primaries, the lanes and walks, the ring lane). */
 export declare function onCapitalStreet(x: number, z: number): boolean;
-export declare function capitalDistrictAt(x: number, z: number): (typeof CAPITAL_DISTRICTS)[number] | undefined;
+/** A plaza, square, court or door apron tile. */
+export declare function onCapitalPlaza(x: number, z: number): boolean;
+export declare function capitalDistrictAt(x: number, z: number): CapitalDistrict | undefined;
 //# sourceMappingURL=capital.d.ts.map